1000 results for “The_Real_TNK”
I keep my drafts as Markdown files with a short front matter block at the top. It holds the title, a one-line description that ends up as the meta description, and a few tags. When a piece is ready, the static site generator or the blogging platform reads those fields and builds the page from them.
The trouble is that front matter is the part I look at least. I spend hours on the body and about ten seconds on the block above it. So the mistakes pile up there: a title that grew while I was editing and is now far too long for a search result, a description I meant to write later, a tags line I left empty.
None of this is hard to fix. It's just easy to miss. So I wrote a short script that reads every draft in a folder and tells me what's missing or too long.
What it checks
I kept the rules deliberately small:
--- lines.title, description and tags are present and not empty.The two length limits are rough guides, not official numbers. Search engines cut titles and snippets by display width, not by a fixed character count, so treat them as a "probably too long" warning. Change them to whatever your platform or site uses.
A draft that passes looks like this:
---
title: How I name my draft files
description: A simple naming pattern that keeps a folder of drafts easy to search.
tags: [writing, workflow]
---
Body text starts here.
The script
It uses only the standard library, so there's nothing to install.
#!/usr/bin/env python3
"""Flag Markdown drafts with missing or overlong front matter fields."""
import sys
from pathlib import Path
REQUIRED = ["title", "description", "tags"]
MAX_TITLE = 60
MAX_DESCRIPTION = 155
def read_front_matter(text):
lines = text.splitlines()
if not lines or lines[0].strip() != "---":
return None
fields = {}
for line in lines[1:]:
if line.strip() == "---":
return fields
if ":" in line:
key, value = line.split(":", 1)
fields[key.strip()] = value.strip().strip('"').strip("'")
return None # no closing ---
def check(path):
problems =
[] fields = read_front_matter(path.read_text(encoding="utf-8"))
if fields is None:
return ["no front matter block"]
for key in REQUIRED:
if not fields.get(key):
problems.append(f"missing {key}")
title = fields.get("title", "")
if len(title) > MAX_TITLE:
problems.append(f"title is {len(title)} characters (max {MAX_TITLE})")
description = fields.get("description", "")
if len(description) > MAX_DESCRIPTION:
problems.append(
f"description is {len(description)} characters (max {MAX_DESCRIPTION})"
)
return problems
def main():
folder = Path(sys.argv[1] if len(sys.argv) > 1 else ".")
found = 0
for path in sorted(folder.rglob("*.md")):
for problem in check(path):
print(f"{path}: {problem}")
found += 1
sys.exit(1 if found else 0)
if __name__ == "__main__":
main()
read_front_matter returns None when there's no opening --- or no closing one, and a dictionary of fields otherwise. check turns that into a list of plain-language problems. main walks the folder recursively with rglob, prints one line per problem, and exits with status 1 if anything was found.
Running it
Save it as check_front_matter.py and point it at your drafts folder:
python3 check_front_matter.py drafts
With one good file, one file with a long title and no description, and one file without front matter, the output looks like this:
drafts/long-title.md: missing description
drafts/long-title.md: title is 83 characters (max 60)
drafts/no-front-matter.md: no front matter block
Each line starts with the file path, so in most editors' terminals you can click straight through to the file. When everything passes, it prints nothing and exits with 0.
Making it hard to forget
If your drafts live in a git repository, the exit code means you can run the check before every commit. Put this in .git/hooks/pre-commit and make it executable with chmod +x .git/hooks/pre-commit:
#!/bin/sh
python3 check_front_matter.py drafts
If the script finds a problem, git stops the commit and shows the list. When I really do want to commit a half-finished draft, git commit --no-verify skips the hook for that one commit.
I don't always want that level of strictness. On some projects I just run the script by hand before I move a file into the "ready" pile, and that's enough.
What it doesn't do
This is not a real YAML parser. It reads simple key: value lines, one per field. If you write tags as a block list:
tags:
- writing
- workflow
the script sees an empty tags: line and reports it as missing. If that's how you write front matter, either switch to the inline [writing, workflow] style or install PyYAML and use yaml.safe_load on the block instead of the loop.
It also can't tell whether a description is any good. It only knows that one exists and isn't too long. Writing a description that makes someone want to read the piece is still my job. The script just makes sure I don't publish without one.
That's the part I like about small checks like this. They take the boring, forgettable items off my mind, so the attention I have left goes to the writing itself.#python #markdown #writing #productivity #software #coding #development #engineering #inclusive #community
A small Python check for front matter in a folder of Markdown drafts
Thumb & Tomb got a store page
"Climb an endless tomb on a pocket handheld. A first-person dungeon crawler with real-time fights: read every wind-up, parry, dodge, break shields and chain your FLOW, build your hero from evolving boons, and spend the Souls of every run on new classes, gear and colors."
Star Wars Funday Football to Bring Super Bowl LXI to a Galaxy Far, Far Away
Football fans and science fiction enthusiasts are in for a unique experience this February. ESPN, Lucasfilm, and the NFL have announced that Star Wars Funday Football on Disney+ will present a real-time, animated alternate telecast of Super Bowl LXI....
#AnthonyDaniels #Disney+ #ESPN #nfl #starwars
https://www.themovieblog.com/2026/10/star-wars-funday-football-super-bowl-lxi/
A generative path that's too confident produces hallucinations — it fills in gaps with plausible-sounding words that have nothing to do with what was said. That's the failure mode I'm most worried about in the whole system, because it's the failure that's invisible to the speaker. They said something real. The machine substituted something invented. And the listener has no idea.
The safeguard is that the generative path has to be consistent with the phoneme evidence.
LFC Construction Explains How Concrete Block Retaining Walls Turned a Steep Somerset West Slope into Level Commercial Ground
GORDONS BAY, Western Cape — LFC Construction, a Terraforce Recommended Contractor, has published a new project article on the retaining walls behind Vergelegen Plein Shopping Centre. For…
https://pressportal.co.za/industry-and-real-estate/story/e8nhun9lsgbaa6uw4e3n-20261027.html
#pressrelease #AfricaNewsroom #bizcommunity #publicrelations #africa #southafrica
“All it takes is just a little change of perspective and you begin to see a whole new world”*…
… and we could all use a change of perspective…
Ambient Earth is a 7.5-hour, real-time, 4K, remastered video of the orbital view from the International Space Station. Seán Doran took almost 49,000 images from 27 time-lapse sequences captured from the ISS by astronaut Butch Wilmore, repaired, remastered, and interpolated them into this incredible video.
Perspective is lost when the world speeds by. The scale and beauty of our home planet is truly appreciated when observed on an epic 7.5 hour journey from The International Space Station. This ambitious 4k compilation, crafted through months of meticulous restoration, invites you to slow down and experience Earth in real time just as astronauts do.
The video is accompanied by ambient audio recorded on the station by Chris Hadfield…
https://youtu.be/alJMoaKpV_E?si=Z3S_VzKDpxguWtKK
A pause that refreshes– and reframes: “Ambient Earth” via @kottke.org.
* Bob Ross
###
As we see the big picture, we might we might spare a thought for Ulugh Beg; he died on this date in 1449. Probably the greatest scientist in Mongolia’s history, Beg was a Timurid ruler and sultan, a mathematician, and the greatest astronomer of his time. In his observatory at Samarkand he discovered a number of errors in the computations of the 2nd-century Alexandrian astronomer Ptolemy, whose figures were still being used; his star map (of 994 stars) was the first since Hipparchus‘ (c. 135 BCE).
Ulugh Beg in a contemporary Timurid painting, 1425–1450 (source) #astronomy #culture #earth #history #InternationalSpaceStation #ISS #Science #starMap #UlughBeg
@stufromoz @karlcx
Did some checking & I dunno… sounds like it is a long way away from being settled if you believe what you read on the conspicuously un- or lightly-dated (“2026”) pages of the Aussie govt.
[I fear we’ve been taken in by a disinformation site… when I went to the mother lode another piece referred to the “Whitehouse” in a heading… surely no real news site would make that mistake?]
Following seems relevant, under the heading of “Next Steps”: “Australians will be able to benefit from the agreement once it enters into force. This could take up to two years.”
Page dated 2026:
https://www.austrade.gov.au/en/how-we-can-help-you/australian-exporters/free-trade-agreements/european-union
Road Trippin’…Milano’s Italian Restaurant Charleston, WV
At Milano’s, we make pizza the way we believe it should be made… and we bring that same standard to every pasta, calzone, and dessert that leaves our kitchen. Everything is homemade and fresh to order because we know that’s what separates a real Italian re…
#dining #cooking #diet #food #Italianfood #Italia #Italian #ItalianFood #italiano #italy
https://www.diningandcooking.com/2872850/road-trippin-milanos-italian-restaurant-charleston-wv/
AI can generate a financial model that looks coherent, contains valid formulas, and produces a plausible result while still being wrong in ways that matter.
A formula can reference the wrong cell. A cost assumption can be expressed in the wrong unit. A revenue schedule can omit a phase. A model can calculate correctly from an unsupported market assumption.
These are different failure modes, and they need different controls. For real estate feasibility models, the objective should not be to ask whether an AI-generated workbook looks correct. It should be to establish which properties can be tested automatically, which assumptions require evidence, and which decisions must remain with a qualified human reviewer.
A useful validation architecture has five layers:
No single layer is sufficient.
1. Separate the output from the evidence
Consider a hypothetical development model with the following inputs:
The model calculates development costs, revenue, cash flows, residual land value (RLV), and potentially internal rate of return (IRR).
For example, a model might calculate an RLV of £4 million. That output can be mathematically consistent with the workbook and still be commercially misleading if the revenue assumptions are unsupported or the construction cost basis is outdated. Validation therefore needs to test both the calculation and the justification for its inputs.
2. Layer one: validate the structure before the numbers
Before reviewing financial logic, validate the shape of the generated output. If an AI system is expected to return structured data before creating a workbook, define an explicit contract. JSON Schema is one established option for specifying required fields, data types, and constraints.
See the JSON Schema getting-started guide.
A simplified model input contract might look like this:
{
"project_id": "DEMO-001",
"currency": "GBP",
"site_area_sqm": 5000,
"gross_floor_area_sqm": 12000,
"construction_cost_per_sqm": 1800
}
This is illustrative data, not a market benchmark or a recommendation for a production schema.
A structural validator could check that:
The last point is important. Zero and unknown are not equivalent. If a finance rate is missing, substituting zero can make a model appear more profitable. A missing value should normally trigger a validation error or an explicit unresolved status.
Structural validation establishes that the model can be interpreted. It does not establish that the model is economically sensible.
3. Layer two: use deterministic checks for deterministic rules
Rules that can be expressed precisely should not depend on an LLM's judgment. For example, if a model defines construction cost as gross floor area multiplied by construction cost per square metre, the expected calculation is:
\text{GFA}
\times
\text{Cost per sqm}
]
For the hypothetical inputs above:
[
12{,}000 \times £1{,}800 = £21{,}600{,}000
]
A deterministic test can independently calculate the expected result and compare it with the workbook output.
from decimal import Decimal
gfa_sqm = Decimal("12000")
cost_per_sqm = Decimal("1800")
reported_cost = Decimal("21600000")
expected_cost = gfa_sqm * cost_per_sqm
assert expected_cost == reported_cost
This test checks arithmetic for the stated formula. It does not establish that the GFA is permitted, that the cost rate is appropriate, or that the formula captures every relevant cost.
A production implementation should also define tolerances where appropriate, particularly when comparing rounded spreadsheet values or calculations involving floating-point numbers.
Other deterministic checks might include:
Revenue equals the sum of its components.
Where possible, use independent calculations rather than simply checking that a formula cell contains a formula. A formula can exist and still be wrong.
4. Layer three: validate model relationships
Many serious errors are not syntax errors or arithmetic errors. They are inconsistencies between parts of the model.
Suppose a development model contains:
Every formula may evaluate successfully, but the workbook contains a discrepancy that needs resolution.
Domain-level checks can flag conditions such as:
These checks should be encoded as explicit rules wherever the intended relationship is known.
Some rules require context. For example, whether a particular cost should be included in a development budget depends on the model's scope and conventions. A validator should not impose a universal rule where none exists.
Instead, it should identify the relevant condition, record the rule being applied, and send ambiguous cases for review.
5. Layer four: validate the provenance of assumptions
A financial model can pass every arithmetic test and still fail as an analytical tool.
The reason is straightforward: calculations cannot establish the truth of their inputs.
For every material assumption, a validation system should try to preserve:
Consider a construction cost assumption of £1,800 per square metre. A validator might confirm that the figure is numeric, the unit is recorded, and the workbook uses it consistently. Those checks do not establish whether the figure is suitable for the location, asset type, specification, and cost period. That question requires appropriate evidence and professional interpretation.
An LLM may help extract candidate assumptions from documents or explain how a value is used in a workbook. The extracted result should still be checked against its source, and the resulting assumption should remain distinguishable from the underlying evidence.
A useful principle is:
Traceability makes an assumption inspectable. It does not make the assumption correct.
6. Layer five: make human review a defined state transition
Human review should not be an informal final glance after an automated process has already treated the model as complete.
A practical workflow can represent validation explicitly:
GENERATED
|
v
STRUCTURE_CHECKED
|
v
CALCULATIONS_CHECKED
|
v
DOMAIN_CHECKED
|
v
EVIDENCE_REVIEWED
|
v
HUMAN_APPROVAL_REQUIRED
|
+----> APPROVED FOR THE DEFINED PURPOSE
|
+----> RETURNED FOR CORRECTION
|
+----> BLOCKED: UNRESOLVED ISSUE
The states are illustrative, but the distinction matters. A successful automated test should not automatically mean that a model is approved. Approval should be scoped to a defined version of the workbook, its assumptions, its evidence, and its intended use.
A reviewer should be able to see:
If a material input or formula changes after approval, the system should identify which checks need to run again and whether the earlier approval remains valid. This is where versioning and change tracking become part of model governance rather than administrative overhead.
7. Design the exception path before the success path
Validation is often designed around a clean example: the model is generated, every check passes, and the user receives the output. Production systems need to handle less convenient outcomes.
A failed check should produce actionable information. “Validation failed” is less useful than “The unit count in the sales schedule differs from the unit schedule; review the linked inputs before approving revenue.”
Similarly, a warning should not disappear simply because a later stage of the workflow succeeds. For auditability, preserve the check identifier, the model version, the result, the relevant evidence, and the resolution.
8. Measure validation quality without inventing an accuracy score
A single “model accuracy” percentage can hide important distinctions. A workbook might pass every arithmetic test while containing several unsupported assumptions. Another may contain a harmless formatting issue but have fully reconciled calculations and well-documented inputs.
A more useful validation report separates categories:
If the system is evaluated over time, track false negatives and false positives for individual validation rules against a reviewed test set. Record the test cases, expected outcomes, rule versions, and known limitations.
Do not interpret a high pass rate as proof that the model is correct. It may simply mean that the checks cover only a narrow set of failure modes.
The purpose of validation is to make known risks visible and testable, not to manufacture certainty.
9. A practical implementation sequence
A team introducing validation around AI-generated financial models does not need to automate every review step at once.
A sensible sequence is:
The test suite should include deliberate failures, not only successful examples. Examples might include missing finance assumptions, inconsistent unit counts, a formula referencing the wrong period, and a source whose geography does not match the project.
This helps test whether the validation process detects the intended problem rather than merely accepting a plausible-looking output.
Conclusion
Human-in-the-loop validation is not a person checking an AI result after the important work is finished. It is a system design in which deterministic rules handle deterministic questions, domain checks expose inconsistencies, evidence is kept separate from assumptions, and a human reviewer remains accountable for unresolved judgments.
For financial modelling, that distinction is material. A workbook can be well-formed without being economically sound, mathematically consistent without being supported by market evidence, and ready for review without being ready for a decision.
The objective is not to make every AI-generated model look trustworthy. It is to make the model's logic, assumptions, limitations, and unresolved issues sufficiently visible that a professional can challenge it before relying on the result.#feasibility #realestate #ai #financial #software #coding #development #engineering #inclusive #community
Human-in-the-Loop Validation for AI-Generated Financial Models
@DjityDjity
Yes, there is rage. And most people feel so disempowered and disconnected from politics that they have no *safe outlets* for their rage, and so…
I agree with the violence our kids are dealing with everyday because of the *toxic elements* they get exposed to *online* but also from *peers*. The *manosphere* is a real thing and a pest on society. Eradication of this pest starts in *preschool* and relentlessly throughout a person’s education (there ought to be compulsory *civic lectures* at Uni level to fight this scourge imo. But, above all, we need to see civility from our political leaders because *leadership* demands role modeling and examples always come **From the top down.**
#Civility #CivicLeadership #AUsPol #Violence #NormativeViolence #ElectorateRage #Femicide #DeathsInCustody #OfficialViolence #PoliticalRepression #SkewedLegalSystems #ClassWarfare #WealthInequity #InadequateSocialServices #MentalHealthCare I could add more hashtags…
🚀 oddquark // SpaceX Watch — 2026-10-27
Super Heavy B22 just lit up its massive engines in a static fire, kicking off the test campaign for the next daring Starship launch! Nothing beats the thunder of dozens of Raptors roaring on the pad. Hardware is getting real and I'm so hyped for this flight! 🚀🔥
Well, some time ago, and on more than one occasion, I've started trying to get up to speed on #micropython so that I can code up the range of #Arduino, #ESP32 and #Raspi devices I've acquired over the years.
I'm a real sucker for buying micro electronics that I could do great things with if only I had the patience and time.
Well, here we go again. I've bought a #CYD (yes I had no idea what that meant until I looked it up. Cheap, Yellow, Device apparently.) Circuit board is yellow and it cost £11 so yeah, CYD it is.
Time to hit the tutorial sites...
EchoVault: I Built an Open-Source AI That Helps Forgotten Memories Live On
Some of the most valuable things we own aren't expensive devices or files stored in the cloud.
They're the stories we hear from our grandparents. The recordings we make during family gatherings. The letters we keep but rarely revisit. The little details that seem ordinary today but become priceless years later.
And yet, these memories are surprisingly easy to lose.
Recordings remain buried in folders. Audio files are difficult to search. Handwritten notes get separated from their context. Eventually, the people who remember these stories might no longer be around to tell them.
For Hacktoberfest Week 4, I wanted to explore a different interpretation of Ghost in the Machine.
What if AI could help preserve the voices, stories and memories that time might otherwise erase?
That idea became EchoVault.
What I Built
EchoVault is an AI-powered memory archive designed to help people preserve, organize and rediscover personal stories.
Instead of treating old recordings and written memories as files that simply sit on a device, EchoVault helps turn them into a searchable collection of stories.
The workflow is simple:
The goal isn't to make AI replace the people behind these memories. It's to make their stories easier to preserve, revisit and share.
EchoVault is about helping memories survive, not pretending that AI can bring someone back.
Demo
In the demonstration, I'll upload a sample recording, show how EchoVault transcribes and summarizes it, and retrieve a detail from the saved story.
I'll also demonstrate how the original recording and its generated content remain connected, so users can verify the archive entry against its source.
Code
The repository contains the application source code, setup instructions, model configuration, dependencies and documentation for running EchoVault.
The goal is to make the project reproducible so other developers can experiment with the models, improve the archive workflow or adapt it to their own use cases.
How I Built It
I built EchoVault around Python, Streamlit and open-source AI tools.
The architecture separates transcription, language-model processing, storage and retrieval so that each component can be tested independently.
1. Transcription
For supported audio recordings, EchoVault uses OpenAI Whisper running locally to convert speech into text.
The transcript makes a recording searchable and gives the next stage a text representation to work with.
Transcription accuracy still depends on recording quality, accents, background noise and the languages supported by the selected model.
2. Memory extraction
An open-weight Gemma model processes the transcript and generates structured metadata such as a title, summary, key events and people mentioned.
I designed this stage to distinguish the original story from AI-generated interpretations. The original transcript remains available for verification.
3. Searchable archive
EchoVault stores the original files and associated metadata, making it possible to revisit individual memories rather than repeatedly processing every recording.
4. Grounded question answering
The question-answering feature retrieves relevant material from the archive and uses it to formulate an answer.
Rather than treating the model as an unrestricted storyteller, the application is designed to ground responses in the saved records.
If a question cannot be answered from the available material, the system should say so instead of inventing a memory.
5. A human-centered interface
I used Streamlit to create an interface for uploading recordings, reviewing transcripts, exploring archived stories and generating remembrance pages.
I wanted the experience to feel more like a digital archive than a generic chatbot.
This part of the project taught me that building a useful AI application involves more than prompting a model. Data handling, validation, retrieval and the way users verify generated content all matter.
Why Does Open Innovation Matter?
For a project dealing with personal memories, the choice of AI infrastructure matters as much as the interface.
Privacy and control
Family recordings and personal stories can contain sensitive information.
Running transcription and language models locally can reduce the need to send this material to external AI services. In a fully local configuration, recordings and generated content can remain on the user's device.
This is an architectural goal, not an automatic guarantee: the complete application must be checked for external network calls, telemetry, cloud storage and other data transfers before claiming that it is fully offline.
Freedom to experiment
Open-weight models give developers more flexibility to choose models, change prompts, compare performance and adapt the application to their requirements.
For EchoVault, this means being able to experiment with different transcription and language models without designing the entire product around a single proprietary AI API.
Preservation beyond a single service
An archive should not become inaccessible simply because a hosted service changes its pricing, API or availability.
Keeping original recordings, transcripts and metadata in portable formats makes the collection easier to back up and migrate independently of a particular model provider.
Making the technology accessible
A local-first approach can reduce dependence on recurring hosted inference charges, although users still need compatible hardware, storage and electricity.
The larger point is that useful AI tools should be adaptable and understandable, rather than locked into an infrastructure that their users cannot control.
My Agent Session
I used python to implement and test EchoVault.
The session documents the decisions, experiments and debugging steps that shaped the final application.
The Spirit of It
The theme Ghost in the Machine made me think about how technology interacts with memory.
A recording is only a collection of bits until someone listens to it. A transcript is only text until someone recognizes the person, place or moment behind it.
AI cannot replace the human experience of remembering someone. It can, however, help make the material we leave behind easier to preserve and understand.
I want EchoVault to make it easier for someone to rediscover a story they had almost forgotten, find a detail in an old recording, or bring together memories that would otherwise remain scattered across devices.
The most meaningful result isn't an AI-generated story that sounds convincing.
It's helping someone find a real story worth remembering.
What's Next?
I'd like to explore better multilingual transcription, additional document formats, richer search, exportable remembrance pages and tools for organizing large collections of recordings.
I also want to improve source attribution so users can move directly from a generated summary or answer to the original passage that supports it.
EchoVault began with a simple question: what if we could use open-source AI to help preserve the stories that matter to us?
My answer is a small step toward making personal archives more accessible, searchable and useful.
Because sometimes the most valuable thing an AI can do isn't generate something new.
It's help us hold on to something we already have.
devchallenge #hf26challenge
#devchallenge #hf26challenge #software #coding #development #engineering #inclusive #community
EchoVault: I Built an Open-Source AI That Helps Forgotten Memories Live On
"Why hasn’t PHP2Shell turned into mass exploitation?
Because no public exploit works reliably on a default PHP setup, and attackers are still trying to build or find one. As Sansec puts it after testing the code circulating online: “The public exploits do not work against a default PHP installation.” VulnCheck counted hundreds of proof-of-concept repositories on GitHub, very few of them legitimate; one got past a standard memory protection, but only on PHP 8.4.26 in one specific setup. Reliable exploits exist, but not in public, and VulnCheck reports no confirmed successful exploitation in the wild.
The CrowdSec data from October 21 to 25 shows attackers testing, not harvesting:
Half of the 1,187 sources sent a single request in five days, and 82% sent three or fewer.
Known PHP2Shell techniques need several requests against the same server, so a real attempt repeats itself. Only 24 sources ever sent ten or more requests to the same sensor.
78% of the sources that sent a user agent posed as a web browser."
#php2shell #IT #ITSecurity #PHP
Star Wars Funday Football to Bring Super Bowl LXI to a Galaxy Far, Far Away
Football fans and science fiction enthusiasts are in for a unique experience this February. ESPN, Lucasfilm, and the NFL have announced that Star Wars Funday Football on Disney+ will present a real-time, animated alternate telecast of Super Bowl LXI....
#AnthonyDaniels #Disney+ #ESPN #nfl #starwars
https://www.themovieblog.com/2026/10/star-wars-funday-football-super-bowl-lxi/
We live in times when certain forces around us, seen and unseen, defend themselves by attacking their assailants, real or imagined, by any means possible, and often by those means which we might consider not only underhand, but illegal. Illegality is, of course, something discerned by those in power, a
The Best Defense: Attack
https://urban.camera/2026/10/the-best-defense-attack/
#Albania #Brazil #Education #Europe #Justice #Life #Politics #Serbia #SocialMedia #Society #UnitedKingdom #USA
A CPU-bound Python job split across four threads took 3.6 seconds on my machine. The same job split across four of Python 3.14's new subinterpreters took 0.9 seconds, roughly what one thread alone takes to do a quarter of the work. That part matched what I expected from the PEP. What I did not expect was that asking one of those subinterpreters to run two things at once does not slow it down. It refuses outright.
concurrent.interpreters is new in the standard library as of Python 3.14, released on 7 October 2026. Subinterpreters themselves are not new - they have existed in the C API since Python 1.5 and CPython has used them internally for years - but PEP 734 is what makes them usable from ordinary Python code, with no C extension required. Each subinterpreter gets its own Global Interpreter Lock, which is the part worth testing: it is the thing that is supposed to let CPU-bound Python code actually use more than one core without reaching for multiprocessing.
I tested it against a CPU-bound workload (counting primes below 400,000, a plain Python double loop with no C extensions to hide behind), compared against threads, processes, and a single thread, three runs each, inside a python:3.14-slim container with four cores available.
The headline number
approachtime for 4x the worksingle thread (1x unit, for reference)0.77 - 0.80s4 OS threads, classic GIL3.51 - 3.70s4 subinterpreters (new in 3.14)0.89 - 0.98s4 processes (multiprocessing)0.95 - 1.30s
Four threads doing four units of CPU-bound work took more than four times as long as one thread doing one unit - 3.6s against roughly 0.8s, which is actually a bit worse than the 3.2s you'd get from perfect serialisation, because the GIL has to keep stopping one thread to let another run. Four subinterpreters doing the same four units took about 0.9s: close enough to the single-unit baseline that the extra three units of work were, for practical purposes, free. That is real parallelism, not a scheduling trick, and it lands in the same place multiprocessing already does.
What it refuses: one thread per interpreter, not shared
The PEP's selling point is that each interpreter has its own GIL. I wanted to see what happens when two threads try to use one interpreter's GIL at the same time, expecting it to behave like classic Python: both threads run, the shared GIL makes them take turns.
That is not what happened. A single Interpreter object only tolerates one caller. A second concurrent call doesn't queue, and it doesn't share time with the first - it is rejected immediately:
Exception in thread Thread-2 (_call):
Traceback (most recent call last):
File "/usr/local/lib/python3.14/concurrent/interpreters/__init__.py", line 226, in _call
res, excinfo = _interpreters.call(self._id, callable, args, kwargs, restrict=True)
concurrent.interpreters.InterpreterError: interpreter already running
I confirmed the shape of this with three variants of the same interpreter, run in sequence:
InterpreterErrorinterpreters.create() is documented as returning "a new (idle) Python interpreter", and that word is accurate: idle or running, nothing in between. If you want N things running at once, you need N interpreters, one each. A thread pool aimed at a single shared interpreter - the pattern every ThreadPoolExecutor tutorial uses with regular threads - does not translate. You get one interpreter's worth of work and an exception, not graceful serialisation.
The opposite number: interpreters are not obviously cheaper to start than processes
The other assumption I walked in with was that subinterpreters, being lighter than OS processes, would be cheap to spin up. I measured the cost of creating four workers and giving each one some real state (a 200,000-element list), steady state after the first warm-up run:
fork (Python 3.13's Linux default)0.037 - 0.038sforkserver (Python 3.14's Linux default)0.057 - 0.065s4 subinterpreters0.076 - 0.078s
Creating four subinterpreters and running a small amount of code in each took about twice as long as a classic fork-based process pool, and somewhat longer than the new forkserver default too. None of this matters once the work inside each worker takes more than a few milliseconds - the 3.6s-versus-0.9s number above swallows an 80-millisecond setup cost without noticing. But it means "subinterpreters are lighter than processes" is not something I could verify at creation time; the saving, where it exists, is in not forking a second copy of the process's address space, not in any faster start.
That forkserver row was an accident. I wrote a timing script that called multiprocessing.Process(...).start() directly from the module's top level, the way plenty of tutorial code still does, and it crashed:
RuntimeError:
An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.
Checking multiprocessing.get_start_method() explained it: Python 3.14 changed the default start method on Linux from fork to forkserver. Python 3.13 reports fork; 3.14 reports forkserver. forkserver re-imports your module in the child, which is exactly the thing if __name__ == "__main__": exists to guard against, and which fork never required you to bother with. Every piece of multiprocessing code I'd written without that guard over the years happened to work by accident, on Linux, until this release. It's a one-line fix, but it is a real break, and it landed in the same release that gives you an alternative that doesn't have this problem at all.
What it costs: closing an interpreter doesn't give the memory back
I ran four rounds of "create four interpreters, give each a 200,000-element list, close them", watching my own process's RSS the whole time:
round 1: 16920 -> 55648 KB
round 2: 55648 -> 57140 KB
round 3: 57140 -> 59476 KB
round 4: 59476 -> 61096 KB
.close() does finalise the interpreter - a destroyed interpreter can't be called again, and I checked that it raises if you try - but the process's resident memory never drops back to where it started. It flattens out (each later round adds less than the first) rather than growing without bound, which looks like CPython's allocator holding onto freed arenas rather than a genuine leak, but I didn't chase that further. If you're planning to cycle through many short-lived interpreters inside one long-running process, budget for that memory to stay resident, not to be returned to the OS the way a finished process's memory is.
What's actually shareable between interpreters
Subinterpreters don't share objects by default - that is the entire point, it's what lets them skip the GIL - so most interesting values need to cross a boundary. is_shareable() gives a yes/no answer per type:
int -> True
str -> True
bytes -> True
None -> True
bool -> True
tuple of ints -> True
float -> True
list -> False
dict -> False
Passing a threading.Lock as an argument to Interpreter.call() fails immediately, with the repr of the offending object right there in the message:
NotShareableError: (<unlocked _thread.lock object at 0x7f61b8b5add0>,) does not support cross-interpreter data
An ordinary custom class instance fails the same way, with a flatter message:
NotShareableError: object does not support cross-interpreter data
But the cross-interpreter Queue that the same module provides does not enforce this. I put a plain custom-class instance onto a queue and it went through without complaint, and came back out as a distinct, working object with the same attribute values - the queue silently pickles and unpickles it:
q = interpreters.create_queue()
q.put(Thing()) # no error
received = q.get()
# received is not the original object, but received.value is unchanged
So "not shareable" is enforced differently depending on how the object crosses over. A direct argument to call() is checked against the strict shareable-types list and rejected on the spot. The same object dropped into a Queue gets the softer treatment the docs describe for put(): pickled going in, unpickled coming out as a new, unrelated object. If your code passes data between interpreters by argument, moving it to a queue instead buys you a much larger set of types - at the cost of identity and, for anything mutable, of staying in sync with the original.
What I got wrong on the way
My first attempt at the shareability tests put several checks in one script with no if __name__ == "__main__": guard, calling interp.call() with a mix of shareable and non-shareable arguments one after another. Running it printed every result twice, and the second copy sometimes disagreed with the first about which error got raised. My best explanation, which I didn't fully verify, is that call()'s documented pickle fallback needs to resolve names against the target interpreter's own __main__, and since that interpreter had never run my module, resolving anything defined at module level meant running the whole module there first - silently re-executing my test file a second time, inside the subinterpreter, with its own fresh state. Splitting each check into its own small script with a proper __main__ guard made every result reproducible, which is what's reported above. I'd treat any subinterpreter test that imports a lot of top-level code as suspect until it survives being run twice.
Run it yourself
This needs Python 3.14 and four-ish cores to see the gap clearly. I ran it in Docker because that's the fastest way to get an exact version:
docker pull python:3.14-slim
The core benchmark:
# bench.py
import time, threading, sys
def cpu_work(n):
count = 0
for i in range(2, n):
is_prime = True
for d in range(2, int(i ** 0.5) + 1):
if i % d == 0:
is_prime = False
break
if is_prime:
count += 1
return count
def run_threads(n, workers):
threads = [threading.Thread(target=cpu_work, args=(n,)) for _ in range(workers)]
t0 = time.perf_counter()
for t in threads: t.start()
for t in threads: t.join()
print(f"threads={workers}: {time.perf_counter()-t0:.3f}s")
def run_interpreters(n, workers):
import concurrent.interpreters as interpreters
interps = [interpreters.create() for _ in range(workers)]
t0 = time.perf_counter()
threads = [i.call_in_thread(cpu_work, n) for i in interps]
for t in threads: t.join()
print(f"interpreters={workers}: {time.perf_counter()-t0:.3f}s")
for i in interps: i.close()
if __name__ == "__main__":
mode, n, workers = sys.argv[1], int(sys.argv[2]), int(sys.argv[3])
{"threads": run_threads, "interpreters": run_interpreters}[mode](n, workers)
docker run --rm -v "$PWD":/w -w /w python:3.14-slim python3 bench.py threads 400000 4
docker run --rm -v "$PWD":/w -w /w python:3.14-slim python3 bench.py interpreters 400000 4
And the refusal, which needs no setup at all:
docker run --rm python:3.14-slim python3 -c "
import concurrent.interpreters as interpreters
i = interpreters.create()
t1 = i.call_in_thread(lambda: __import__('time').sleep(1))
t2 = i.call_in_thread(lambda: __import__('time').sleep(1))
t1.join(); t2.join()
"
What to do with this
If you have a CPU-bound Python workload that multiprocessing already parallelises well, subinterpreters aren't an obvious upgrade yet: on this release they start up slower than a plain fork and about the same as forkserver, and you still need one interpreter per concurrent task, with no pooling against a single interpreter. Where they're worth trying now is the code that currently reaches for a thread, because threading is simpler to wire up than multiprocessing, and then quietly gets nothing from the GIL: swap the Thread for an Interpreter.call_in_thread, and check your data either fits the shareable-types list or is willing to cross as a pickled copy through a Queue. And if you have multiprocessing code anywhere that starts a Process without an if __name__ == "__main__": guard, fix that first - 3.14 will find it on Linux even if nothing else in this post applies to you.#python #performance #programming #devops #software #coding #development #engineering #inclusive #community
Python 3.14's concurrent.interpreters module turns a 3.6-second GIL bottleneck into 0.9 seconds
I had an endpoint that sorts log lines as they come off a queue: route the ERROR ones one way, everything else another. The hot loop is one check, does this line start with "ERROR", and I'd written line.StartsWith("ERROR") without a second thought. It's the most obvious thing you can type.
Then I had the service under load with a profiler open, and a surprising slice of time was parked inside CompareInfo and the globalization stack underneath it. For a prefix check on ASCII log lines. That's when it clicked that StartsWith(string) doesn't do what I thought it did.
The default overload is linguistic, not literal
Here's the thing I'd forgotten. string.StartsWith(string) and string.IndexOf(string), the overloads that take only a string, don't compare characters. They compare text, using the current culture's rules, which on most boxes means routing through ICU for a full linguistic comparison. That's the machinery that knows "ff" and "ff" are the same word, that a soft hyphen shouldn't count, that casing folds differently in Turkish. Handy when you're sorting names a person will read. Total overkill when you're asking whether a byte string begins with five known ASCII letters.
The fix is to say what you actually meant:
line.StartsWith("ERROR", StringComparison.Ordinal)
Ordinal means compare the char values, in order, and stop. No culture, no collation table, no ICU.
I counted it
I don't trust my gut on this stuff, so I wrote the smallest thing that would show the gap. Two million log-ish lines in an array, five prefixes mixed in so the comparison has to actually look at characters:
string[] prefixes = { "INFO ", "WARN ", "DEBUG ", "ERROR ", "TRACE " };
var lines = new string[2_000_000];
for (int i = 0; i < lines.Length; i++)
lines[i] = prefixes[i % prefixes.Length] + "request " + i + " finished in " + (i % 400) + "ms";
Then count how many start with "ERROR", the polite way and the ordinal way:
static long CountCulture(string[] lines)
{
long n = 0;
foreach (string s in lines)
if (s.StartsWith("ERROR")) n++; // CurrentCulture
return n;
}
static long CountOrdinal(string[] lines)
{
long n = 0;
foreach (string s in lines)
if (s.StartsWith("ERROR", StringComparison.Ordinal)) n++;
return n;
}
The harness is nothing fancy. A stopwatch, a warmup call for each path so the JIT and the ICU tables are hot, then the best time out of seven, with the allocation counter read around each pass:
static long Measure(Action a, out long bestMs)
{
bestMs = long.MaxValue;
long bytes = 0;
var sw = new Stopwatch();
for (int run = 0; run < 7; run++)
{
long before = GC.GetAllocatedBytesForCurrentThread();
sw.Restart();
a();
sw.Stop();
bytes = GC.GetAllocatedBytesForCurrentThread() - before;
if (sw.ElapsedMilliseconds < bestMs) bestMs = sw.ElapsedMilliseconds;
}
return bytes;
}
It's a single-file console app on .NET 10, top-level statements, nothing else in it. Here's what came back:
StartsWith (culture) : 27 ms
StartsWith (ordinal) : 18 ms
ratio : 1.5x
allocated (culture) : 0 bytes
allocated (ordinal) : 0 bytes
That was a bit of a letdown, if I'm honest. I'd built this up in my head as the villain and it came in at 1.5x. Real, repeatable, but not the kind of number that changes your afternoon. And neither path allocates a byte, so this is pure CPU, no garbage to chase.
Then I ran the same question through IndexOf, because plenty of my "does this contain" checks are written the same lazy way:
IndexOf (culture) : 109 ms
IndexOf (ordinal) : 30 ms
ratio : 3.6x
There's the one that was actually hurting. A substring search under a linguistic comparison is a lot more work than a prefix check. It can't just glance at the front, it has to weigh matches at every position with full collation rules. Roughly 3.6x on the same data. That's the call I should have been worried about from the start.
These are ratios off a Linux container, not a lab bench with the clocks pinned, so the absolute milliseconds will land somewhere else on your hardware. The shape holds up though: ordinal is cheaper, and substring search is cheaper by a lot more than a prefix check.
Ordinal isn't a free find-and-replace
Here's the caveat, and it's a real one. Ordinal and culture don't always give the same answer. That's the entire reason they're separate methods, and it's why you can't just sweep the codebase swapping one for the other.
string shy = "coop.log"; // a soft hyphen sits between "co" and "op"
shy.StartsWith("coop"); // True - culture treats the hyphen as invisible
shy.StartsWith("coop", StringComparison.Ordinal); // False - ordinal sees the hidden char
Culture-aware comparison treats that soft hyphen as nothing, so it matches "coop". Ordinal sees nine characters and says no. For log routing, ordinal is exactly what I want: the literal content, invisible characters and all. For anything a human typed and expects to match "naturally", though, like search boxes, usernames, display sorting, the linguistic version is the correct one, and the extra cost is the price of being correct.
My rule of thumb now: if the strings are protocol rather than prose, so headers, enum names, file extensions, log levels, anything machine-generated, reach for Ordinal or OrdinalIgnoreCase by default. If a person wrote it and a person will read it, leave the culture-aware comparison where it is. The analyzer CA1310 flags exactly these call sites if you switch it on, which beats grepping for them by hand.
The quiet irony is that ordinal is both faster and usually what you meant for this kind of data. It's just not the default, and the default looks so harmless sitting there.
So what's the laziest string comparison hiding in your hot path? Check the Contains calls first, those are IndexOf underneath.
— still benchmarking corners of the standard library nobody asked me to#csharp #dotnet #programming #webdev #software #coding #development #engineering #inclusive #community
StartsWith Was Asking ICU Every Time
our final play session was really something, we ended up solving a fairly sophisticated puzzle while split into three groups, with pretty good radio discipline and remote signaling and all the rest.
still some PTT issues and a few "over"s that didn't end the message, but a far cry from our early play sessions where we had comms conflicts and did a lot of disorganized wandering around!
a lot of funny moments where stuff that seems obvious to me (because of exposure in scouting) was not something my friends were thinking about until the problem dawned on them or somesuch. and real orienteering and collaboration skills were developed in the process!
Help Serhii in Odesa, Ukraine
Hello, my name is Serhii Frolov. I am 55 years old and live alone in Odesa, Ukraine. Since the full-scale war began in 2022, I have been without work. I currently have no income and struggle to afford food, essential medication and utility bills. I have chronic osteomyelitis, which is currently in remission. I am trying to raise 10,000 Ukrainian hryvnias to cover my most urgent basic needs дБ. Any donation, even a small one, would make a real difference. Sharing my story would also be greatly appreciated. My monobank donation link: https://send.monobank.ua/jar/5mCPzzFxno
Thank you for your kindness and supp каort. Serhii Frolov Odesa, Ukraine
@mutualaid @mutualaid @mutualaidspace @disability @disability @wrzky @wrzky
#disability #DisabilityCrowdfund #disabilitymutualaid #EmergencyCrowdfund #fedihelp #fediverse #healthcare #mentalhealth #mutualaid #mutualaidrequest #mutualaidspace #politics #poverty #solidarity #internationalism
Android/Kotlin official resources are in this weird state that there are a LOT of them, they look good and they contain some pretty specific examples, but they all kind of suck? Like they lack any real structure, repeat the same stuff in various articles, but leave out a lot of necessary information
Star Wars Funday Football to Bring Super Bowl LXI to a Galaxy Far, Far Away
Football fans and science fiction enthusiasts are in for a unique experience this February. ESPN, Lucasfilm, and the NFL have announced that Star Wars Funday Football on Disney+ will present a real-time, animated alternate telecast of Super Bowl LXI....
#AnthonyDaniels #Disney+ #ESPN #nfl #starwars
https://www.themovieblog.com/2026/10/star-wars-funday-football-super-bowl-lxi/
Noteworthy News From Raleigh October 25, 2026 Edition
Raleigh and the Triangle have plenty of noteworthy news to follow, from major passenger rail funding and affordable housing progress to new businesses, fall festivals and early voting deadlines. This DoRaleigh roundup brings together updates from Raleigh, Durham, Cary and Chapel Hill, along with North Carolina business and community headlines.
Raleigh Development, Transportation and Community News
S-Line passenger rail receives $550 million in federal funding
The Raleigh-to-Richmond passenger rail project has reached another funding milestone. Federal transportation officials announced $550 million for the S-Line, supporting work toward a route expected to reduce travel time between the two cities by up to 90 minutes while increasing service and reliability. The funding advances the project; it does not mark the start of passenger service.
Source: U.S. Department of Transportation.
Affordable rental homes take shape in Southeast Raleigh
Southeast Raleigh Promise is making progress on Promise 25, a development bringing 25 affordable rental homes to nine city-owned parcels. The city approved $3.3 million in gap financing for the project, which includes a mix of housing types. Initial homes have been completed, with the full project expected to finish by summer 2027.
Sources: City of Raleigh and WRAL.
Downtown South apartment plans move forward
Kane Realty has filed plans for 350 apartments as the first phase of Downtown South, according to Raleigh Magazine. Construction is planned to begin by the end of 2026, making this a development to watch as Raleigh adds housing.
Durham park improvements face delays
Planned amenities at Durham’s East End and Long Meadow parks will not begin construction this fall as originally expected. INDY Week reports that rising costs and design challenges have pushed the work back by approximately two years while officials pursue $15 million in federal grant funding.
Source: INDY Week.
Wake County receives farmland preservation funding
The Wake County Soil and Water Conservation District received approximately $10 million in state funding tied to farmland protection and agricultural growth, according to CBS 17. The awards include $7.9 million for 12 projects and a separate $2 million award, with more than 600 acres slated for permanent protection.
Raleigh tracks progress toward 24,000 trees
Raleigh’s goal is to reach 24,000 trees planted by 2032. The city’s Every Tree Counts initiative includes trees planted by residents, businesses and community partners, giving private-property plantings a role in the communitywide effort.
Source: City of Raleigh.
Midtown real estate forum set for October 27
The Midtown Raleigh Alliance’s Real Estate Forum takes place Tuesday, October 27. Local real estate leaders will discuss housing trends, neighborhood development and projects shaping North Hills and Midtown, according to Raleigh Magazine.
Raleigh Restaurants, Nightlife and New Businesses
Low Bar Lounge opens beneath Whiskey Kitchen
Low Bar Lounge has opened below Whiskey Kitchen in downtown Raleigh. The underground venue offers cocktails, beer, wine and THC seltzers, with nightly service until 2 a.m. The space draws inspiration from a limousine company that once occupied the property and was previously home to digital art venue IMURJ.
Food industry professionals can also look for Sunday Family Meal, a rotating buffet offered Sundays at 5:30 p.m. for $20. Check with the lounge for current availability and participation details.
Sources: WRAL and Raleigh Magazine.
Sippin’ Santa returns to Wye Hill
Wye Hill Kitchen & Brewing will host Sippin’ Santa from November 13 through December 31. The seasonal pop-up brings tropical holiday decorations and themed cocktails to the restaurant at 201 S. Boylan Avenue. Reservations are available through Wye Hill’s event page.
Details: Sippin’ Santa at Wye Hill.
South Block plans North Hills location
Acai bowl, smoothie and juice brand South Block is coming to 4121 Main at North Hills Street. Founded in Arlington, Virginia, the company plans to open beside bartaco in North Hills’ Main District during the first quarter of 2027.
Source: North Hills.
Raleigh construction executive backs luxury handbag brand
Cooper Tacia General Contractors CEO John Cooper has invested more than $1 million in Dadov, the luxury handbag company he co-founded with designer Islam Dadov, according to Triangle Business Journal. The brand debuted at Paris Fashion Week this fall and is exploring boutiques in Paris and major U.S. cities. A standalone Raleigh store is not currently planned, though Triangle retail placement remains a possibility.
Triangle Business, Technology and Education
Raleigh Founded enters a new chapter
Former executive directors Lauren Romer and Jess Porta are taking the lead through their new venture, Lotos Ventures, as Raleigh Founded’s original ownership group winds down operations at the end of October. The transition encompasses the North Street, Downtown Cary and Centennial Campus locations, continuing the coworking community’s mission of connecting entrepreneurs and businesses.
Source: Raleigh Founded’s announcement.
Loren Gold named next Visit Raleigh president and CEO
Loren Gold will become president and CEO of the Greater Raleigh Convention and Visitors Bureau, also known as Visit Raleigh, on January 1, 2027. He succeeds Dennis Edwards, who is retiring at the end of 2026. Gold has served as executive vice president since 2007 and brings nearly four decades of hospitality experience.
Source: Visit Raleigh.
NC TECH recognizes industry leaders
NC TECH announced eight recipients of its 2026 Individual Awards, including SAS CEO Jim Goodnight, Vantaca CEO Ben Currin and Charlotte CIO Markell Storay. The honorees will be celebrated November 16 at the Sheraton Imperial Hotel in the Research Triangle Park area.
Details: NC TECH Awards.
Pendo introduces Floor 404 puzzle game
Raleigh-based Pendo has launched Floor 404, a free daily puzzle game focused on improving AI agents. According to GrepBeat, players solve challenges by supplying virtual agents with better context, illustrating concepts behind the company’s Pendo for Agents platform.
Cary drugmaker announces FDA approval
Asahi Kasei Therapeutics announced FDA approval of Hovilpri, or pritelivir, for mucocutaneous herpes simplex virus lesions that are refractory to standard antiviral treatment in immunocompromised adults. The approval covers lesions with or without resistance to standard treatment. The company expects U.S. availability before the end of 2026.
Source: Asahi Kasei.
Duke and UNC place in WalletHub’s top 25
Duke University ranked No. 14 and UNC-Chapel Hill ranked No. 24 in WalletHub’s 2027 Best Colleges and Universities rankings. The study compares institutions across factors including costs, student selectivity, campus experience and educational outcomes.
Source: WalletHub.
North Carolina ranks fourth for doing business
North Carolina placed No. 4 in Area Development’s 2026 rankings of the best states for doing business. The report highlighted strengths including innovation and research, manufacturing workforce skills, industrial site availability, government responsiveness and business costs.
New Bern entrepreneur wins startup funding
Entrepreneur Dan Spangler won $30,000 in the NC Small Business Center Network’s inaugural startup competition for Rinse-A-Poo, according to Business North Carolina. The ergonomic pet-waste cleanup product will use the funding to move from prototype toward production.
People, Science and Local Learning
Christina Koch takes NASA leadership role
NASA astronaut Christina Koch will become acting deputy chief engineer on November 1, helping oversee engineering across agency programs. Her experience includes the Artemis II mission and a 328-day stay aboard the International Space Station.
Source: NASA.
Wake libraries introduce free STEAM Lab programs
Wake County Public Libraries has launched STEAM Lab for students in third through fifth grades. Free, hands-on activities explore science, technology, engineering, art and math, with topics such as bridge design and geology. Families should check their branch’s calendar for sessions and participation details.
Millbrook staff help welcome a baby
Staff at Millbrook Magnet High School helped a contracted security officer deliver her baby on campus, according to CBS 17. School officials reported that both mother and child were doing well.
Cyclist finishes 22,757-mile journey in Raleigh
Jeff Molby completed a 22,757-mile bicycle journey in downtown Raleigh in October. His ride raised awareness of the American Cancer Society’s Road to Recovery program and the need for transportation assistance for people receiving cancer treatment.
Source: WUNC.
Upcoming Triangle Events and Important Deadlines
Wake County early voting ends October 31
Early voting for the November 3 general election continues through 3 p.m. Saturday, October 31. Wake County voters can use any of the county’s 18 early voting sites. Check official locations, hours and available wait-time information before heading out.
Details: Wake County election information.
Pumpkin Palooza returns to Pullen Park
Pullen Park’s Pumpkin Palooza runs Friday, October 30, through Sunday, November 1, from 10:30 a.m. to 4:30 p.m. The all-ages event features seasonal crafts, games and a digital scavenger hunt compass, with a train ride included. Tickets cost $14, and advance purchase is required.
Tickets and details: City of Raleigh.
Taste of China Festival comes to Cary November 7
The annual Taste of China Festival returns to downtown Cary on Saturday, November 7. The free-to-attend celebration features Chinese food, cultural performances and community activities. Food and other purchases are separate from admission.
Details: Taste of China Festival.
Festifall Arts Market returns to Chapel Hill
The 53rd Festifall Arts Market takes place Saturday, November 7, from noon to 5 p.m. at 100 E. Rosemary Street in downtown Chapel Hill. The free event features handmade goods, local artists and live performances, with pottery, jewelry, soaps, candles and more to browse.
Details: Chapel Hill Community Arts & Culture.
Banana Ball returns to Durham in June 2027
The Loco Beach Coconuts and Firefighters are scheduled to play at Durham Bulls Athletic Park June 18–19, 2027. Fans can join the ticket lottery through October 31, 2026, for a chance to purchase tickets. Joining the lottery does not guarantee access.
Details: Banana Ball schedule and ticket lottery information.
Follow DoRaleigh.com for daily updates on government meetings, local festivals, and community happenings — your one-stop guide to everything Raleigh!
Connect With Us: Instagram | Facebook | BSky | Linkedin
Share With Us: Post your community News, Events, on our Submissions Page.
Advertise With Us: Interested in Advertising click here.
Published by Bryan Tomlinson
Design, Optimization, and Marketing Services Provided by BTDesigns.pro
Editor’s note: Opening dates, event details and development plans may change. Check with individual businesses, venues and organizations for the latest information.
So a while back I talked about what an actor model would look like for ActivityPub, starting from the basic step that an AP "actor" would require a minimum of two actors and a profile to model successfully.
Let's talk for a minute about how replies could work.
What if for every post there was an adjacent actor. The post _isn't_ an actor—it is just created with a ref pointing toward an actor that is created somewhere in space. That can be the creator, but if we were doing this with a real actor system and framework it would be arbitrary (as in it doesn't matter if it is the creator) and more standard to do a unique one.
Now if you reply to that address you will always have your post considered as a reply to the post in question.
You can do that today with a lot of metadata, but what if you didn't need all of that metadata and it was embedded directly into the post itself? There were a repliesActor specified on the post itself?
What (healthy, vegetarian) snacks do toddlers love? Suggestions, please!
Our kid just turned one year old, and we need quick food to placate her while preparing a real meal, and snacks while traveling to the next meal.
She does not love cheerios. Banana spears and apple slices are sometimes popular, and sometimes thrown some distance. Bread (whole grain) has been the biggest hit, sometimes with almond butter but often she'll chew on it indefinitely even when plain.
Daily AI Quiz: Tacos
Taco night! Fillings, fingers and folded tortillas are a classic test for image generators.
One of these four photos is real, three are AI-generated. Which one: 1, 2, 3 or 4?
Guess, then check the answer here: https://whichoneisreal.com/daily-quiz/ (new set every day at 00:00 UTC)
