DEV Community: w4ffl35

Artificial Technology Scarcity and the End of First Amendment Rights on the Internet

w4ffl35 — Sun, 01 Nov 2026 18:07:00 +0000

We are watching the death of personal technology, the First Amendment, and the internet in one fell swoop.

Elon Musk has already shown us how much control one person can exercise over online speech by purchasing Twitter and reshaping the platform. “Freedom of speech, not freedom of reach”—the cry of any true statist. You can speak, but the owner decides whether anyone hears you. ¹

The federal government strongly backs AI companies. OpenAI put former NSA director Paul Nakasone on its board. xAI announced a military partnership. Anthropic supplied Claude for military and intelligence work before its confrontation with the Pentagon. The companies inviting us to pour our private lives into a chat window have built businesses around the institutions we should most want to keep out of it. ²

Your conversations are monitored and flagged on these platforms. OpenAI says it sends flagged conversations through human review and notifies law enforcement when it identifies an imminent and credible risk of harm to others. Anthropic’s published policy permits government disclosures under valid legal process and in emergencies involving imminent physical harm or death. A private company’s judgment can put your conversation in government hands. ³

Washington is helping build this industry while working to push aside state restrictions. We are told to move faster in the name of national security and winning the AI race. Think about the reaction to 9/11 and the rush into a war that lasted 20 years. When someone insists there is no time to question where they are taking you, question it.

Both parties are backing this buildout. I see us being pushed toward artificial technological scarcity: a future in which owning the means to compute becomes harder, renting access becomes normal, and speaking online depends on clearing somebody else’s checks. To me, this frenzy has all the hallmarks of a psychological operation.

I wrote the original introduction and directed the research using Codex GPT-6.1 Sol. The original research, outline and article draft were produced with AI assistance.

Computing on Their Terms

Sam Altman has explained exactly what bothers him about people running AI locally. In his late-October Cheeky Pint interview, he called allocating scarce DRAM to personal computers used only a small fraction of the time “quite terrible.” He preferred “maximum utilization in the cloud.” In his calculation, memory serves the world better inside a data center than inside your computer. ⁴

I bought my computer to run software when I choose, keep my work private, and continue using it when a company changes its prices or decides it no longer wants my business. Sam Altman’s utilization figures have nothing to say about the value of that independence. Memory sitting idle on my desk is still mine to use.

OpenAI has the purchasing power to help shape the market behind that argument. Its October 2025 announcement with Samsung and SK described plans targeting 900,000 DRAM wafer starts per month. On October 31, Altman met about 50 Samsung executives in Yongin to discuss AI strategy, according to Samsung’s account reported by Yonhap. That is the scale at which it negotiates for the hardware the rest of us also need. ⁵

Micron announced its exit from the Crucial consumer business in December 2025, explicitly tying the decision to AI demand and serving larger strategic customers. It set February 2026 as the end of consumer-channel shipments. TrendForce’s fourth-quarter research says suppliers are still prioritizing advanced capacity for server products, forecasts conventional DRAM contract prices rising another 10–15%, and warns that PC memory supply could shrink in 2027 as more capacity moves to servers. Consumers are being pushed down the list of priorities, and the manufacturers are telling us why. ⁶

Factories take time to build. Production limits are real. So are the decisions about which customers get served and which businesses get abandoned. Calling the result a shortage does not put those decisions beyond criticism. When the industry channels capacity toward enormous buyers and then offers everyone else a subscription, scarcity becomes a way to make dependency profitable.

Owning high-end consumer hardware is already expensive. Nvidia launched the RTX 4090 at $1,599 and the RTX 5090 at $1,999. The starting price of admission to its flagship consumer tier rose by $400 between generations, before retailer markups. ⁷

Its software makes leaving expensive, too. France’s competition authority identified the proprietary CUDA ecosystem among the barriers facing generative-AI competitors. Software built around one vendor’s hardware takes work to move. A competing chip does little for your independence if your software keeps you tied to the incumbent. ⁸

The FTC’s January 2025 report on Microsoft–OpenAI, Amazon–Anthropic and Alphabet–Anthropic documented cloud-spending commitments, control and exclusivity rights, and switching costs. These arrangements have since changed: in April 2026, OpenAI and Microsoft announced that OpenAI could serve all its products across any cloud provider and that Microsoft’s model license would become non-exclusive. Microsoft remained its primary cloud partner and a major shareholder, with OpenAI’s revenue-share payments continuing through 2030, subject to a cap. The restrictions are negotiable. Regulators should demand to know which ones remain and what it costs a smaller rival to escape them. ⁹

Antitrust enforcement should go straight at these contracts. Investigate the exclusive terms, the restrictions on switching providers, and acquisitions that eliminate independent competition. Enforce the Sherman Act against anticompetitive restraints and monopolization, and the Clayton Act against acquisitions that substantially threaten competition. The public should not have to wait until every affordable alternative has disappeared before regulators act. ¹⁰

Washington is helping finance the buildout. Biden’s January 2025 infrastructure initiative proposed federal sites for private AI development. Trump’s July 2025 order directed an initiative for financial support that could include loans, guarantees, grants, tax incentives and purchase commitments. Routes to qualification included projects committing at least $500 million or adding more than 100 megawatts. Across administrations, federal support has been organized around enormous infrastructure projects. ¹¹

The December 2025 order directed a federal task force to challenge state AI laws, threatened funding pressure against certain state restrictions, and called for a national framework preempting conflicting laws. Attorney General Pam Bondi established the task force on January 9, 2026. On April 24, DOJ moved to intervene in xAI’s lawsuit against Colorado’s AI antidiscrimination law. Washington is putting federal lawyers behind an AI company’s attack on state regulation. The public deserves a government willing to confront this industry, not one that treats its objections as marching orders. ¹²

If public money is going into computing infrastructure, the public should gain independence from it. Universities, small businesses and individual developers need durable access they can use without becoming permanent customers of a handful of corporations. A temporary allocation of cloud credits cannot substitute for an independent computing sector.

The military relationships make that independence more urgent. OpenAI says its Pentagon agreement prohibits domestic surveillance of U.S. persons and that NSA use would require a separate agreement. Those commitments should be enforceable and independently checked. My privacy should also survive a future contract change. A corporate promise is a poor substitute for keeping my work on hardware I control. ¹³

Anthropic refused to remove its restrictions on mass domestic surveillance and fully autonomous weapons, and the administration branded it a supply-chain risk. On August 27, 2026, Judge Rita Lin ruled that the government had retaliated against Anthropic’s protected speech and denied it due process; she rejected the Pentagon’s designation under 10 U.S.C. § 3252 and the broader effort to force other contractors to cut ties. On September 25, a divided D.C. Circuit upheld a separate procurement exclusion under the Federal Acquisition Supply Chain Security Act, accepting the Pentagon’s argument that Anthropic’s embedded use restrictions could interfere with military operations. Those decisions address different government actions under different statutes. ¹⁴

Anthropic sought rehearing, and on October 15 the appeals court ordered the government to respond. The government has already used its purchasing power to punish a supplier that refused to abandon limits on surveillance and weapons. Anthropic was right to resist. I do not want the privacy of millions of people hanging on whether one company can afford to hold its ground against the Pentagon. Hardware we own, software we can run ourselves, and enforceable limits on government surveillance matter more than any executive’s promise to stand firm. ¹⁴

Meanwhile, the consumer services are building records of what people say to them. OpenAI describes automated analysis, human assessment of flagged conversations and law-enforcement referrals in qualifying cases. Anthropic says it can retain flagged inputs and outputs for up to two years and trust-and-safety classification scores for up to seven. A company’s judgment about your conversation can outlast the conversation itself. ³ ¹⁵

There are rules governing disclosure: legal process, emergency exceptions, and separate reporting obligations for specified child-sexual-exploitation offenses. The reporting statute expressly says it does not require providers to monitor or search users’ communications. Companies should explain which disclosures the law compels, which it permits, and which monitoring practices they choose themselves. Users deserve that answer before their thoughts become somebody else’s retained records. ¹⁶

The intelligence value of commercial information is already understood inside government. ODNI’s declassified advisory report describes the sensitivity of commercially available data, the privacy risks of aggregation, and the possibility of identifying people in supposedly anonymous information. The intelligence community now has a formal policy framework for acquiring and handling that information; ODNI’s first biennial public report was declassified in September 2026. The government is organizing access to the commercial data economy. Putting more of our lives into that economy creates more information to seek, compel or acquire. Minimize collection and retention at the source. ¹⁷

Age-verification laws introduce another condition on access. Bluesky initially blocked Mississippi because of the compliance burden, then reopened access for adults completing age assurance while continuing to exclude minors. Mississippi users first lost the service entirely and then had to complete a check to get back in. The compliance burden fell on a smaller competitor and the people trying to use it. ¹⁸

Courts are allowing significant restrictions. In October 2026, the Eleventh Circuit removed the preliminary injunction against Florida’s restrictions on accounts for children under 14 and on accounts for 14- and 15-year-olds without parental consent, reversing in part, vacating in part and remanding the case. In 2025, the Supreme Court upheld Texas’s age-verification requirement for covered commercial sites distributing sexual material obscene to minors. These decisions concern different laws and different speech, but both belong in the argument over how much of the internet should require proof of eligibility to enter. ¹⁹

The access checks are spreading. On October 29, 2026, Ofcom identified photo-ID matching, digital IDs, banking checks and facial age estimation as methods capable of supporting the UK’s announced under-16 social-media ban, with detailed rules still to come and implementation expected in 2027. Every imposed check adds a system that can reject people, a company entrusted with information, and a compliance cost a small service must absorb. Protecting children does not relieve lawmakers of the obligation to justify those burdens. I reject the idea that ordinary participation online should gradually become something we have to qualify for. ²⁰

We are being trained to accept dependency in the rest of our technology, too. GeForce NOW gives Performance and Ultimate subscribers 100 monthly hours of premium playtime, with paid extensions and limited rollover. Sony requires an internet connection to pair the separately sold PS5 Pro disc drive during setup. You can buy the console and the drive and still have to contact Sony to finish pairing them. ²¹

Independent publishing depends on being able to operate without a narrow set of institutions granting permission. Broadcasting’s history shows how scarcity and access rules can become entangled. In Reno v. ACLU, the Supreme Court distinguished the internet from broadcasting when striking down online-indecency restrictions. Preserving the internet’s capacity for independent publishing requires defending the infrastructure that makes it possible. ²²

Private platforms have editorial rights of their own. That makes the ability to leave them essential. Government officials also face a constitutional limit: they cannot coerce private intermediaries into suppressing disfavored advocacy. NRA v. Vullo reaffirmed that principle. A government should not be able to accomplish through pressure on a provider what the Constitution forbids it to impose directly. ²³

Anonymous political speech also has constitutional protection. McIntyre v. Ohio Elections Commission struck down an identification requirement for campaign literature. Anonymity lets people criticize power without first presenting their identity to it. I want that freedom to remain practical on the internet. ²⁴

The First Amendment can remain on paper while the means to exercise it move out of reach. Price people out of owning useful hardware, make independent services expensive to operate, and place more checks between a person and an audience. The result is an internet in which formal rights coexist with a shrinking ability to act on them.

Enforce competition law. Demand interoperable software and affordable consumer hardware. Put public computing investment to work building independent capacity. Challenge access restrictions that burden speech, limit data retention and government access, and protect encryption and anonymous participation.

Above all, refuse the demand to surrender these things because an executive says the race is urgent. The people asking us to accept permanent dependence are the people who stand to profit from it. Their timetable does not outrank our freedom.

I want affordable local computing, strong encryption, anonymous participation, and continued offline access to purchased media.

I want a computer I control and an internet I can use without asking a corporation or the state for permission.

Sources

Clip Studio Paint EX 1.13.2 on Linux with Wine

w4ffl35 — Tue, 06 Oct 2026 16:49:07 +0000

Clip Studio Paint EX 1.13.2 on Linux with Wine

I bought Clip Studio Paint EX 1.13.2 a few years ago and wanted to keep using it on Linux.

It opens on my Debian 13 desktop through Wine, and I was able to sign in. I wrote down the setup I used, including the XP-Pen Deco LW (IT1060B) notes, in linux-clipstudio-installer.

Wine is unofficial, so I don't know how it will behave on every system. The installer doesn't include Clip Studio Paint or bypass license activation.

What I split into public Capsize packages

w4ffl35 — Wed, 30 Sep 2026 15:15:01 +0000

I didn't set out to make a pile of tiny repos. I kept finding code that already had one clear job and could be useful outside the app where it started. This week I gave those pieces their own public homes.

The companion and social pieces are the largest group:

capsize-auth provides password, token and OAuth2 primitives.
capsize-bluesky is the AT Protocol client used by the social tools.
capsize-social handles Bluesky and Discord account connections.
capsize-voice measures a writing style and uses that profile during generation.
capsize-persona combines persona, voice and long-term conversation facts in a reply service.
capsize-memory provides SQLAlchemy models and functions for rooms, participants and conversation turns.

That was the test: does this piece have one job, and can another app use it on its own? A bot can use the Bluesky client without loading the persona service. A local chat app can keep conversation memory without knowing anything about Discord. An app can also hand capsize-memory its own database session. The package doesn't need to own the connection.

The supporting repositories cover a different layer:

capsize-commons contains selectively installable Python, TypeScript and C++ building blocks.
capsize-ci contains versioned reusable GitHub Actions workflows.
capsize-fastmail reads Fastmail through JMAP, including mailbox listing, pagination and delta sync.
capsize-github-traffic saves repository traffic history before GitHub's 14-day window drops it.

AIRunner had the same problem. I split out airunner-common, airunner-eval, airunner-native and airunner-tts-vendor. Shared code, agent tests, the native launcher and the MeloTTS/OpenVoice layer no longer need to move as one block.

A practical way to use the split

Start small. If an app only needs Bluesky, use capsize-bluesky. If it needs account storage and posting across services, add capsize-social. Bring in memory, voice or a persona only when the app needs it.

The same rule applies to AIRunner. Its launcher shouldn't own the eval harness, and the eval harness shouldn't drag in the desktop app. The split makes that obvious. It also lets each piece ship when it's ready.

I want these repos to stay small enough to read. If one starts collecting unrelated work, that is a sign that the boundary has gone bad. The point is not the repo count. The point is being able to use one part without hauling the rest of the system behind it.

The full list, including commit and release counts, is in the four-week Capsize report.

Sharing Django plumbing with capsize-commons

w4ffl35 — Tue, 29 Sep 2026 15:15:01 +0000

I published capsize-commons, then used it in sites that already existed. A shared package does not help much if every live site keeps its own copy of the same settings and health checks. Shipping it was only the start.

The Python package now carries shared settings construction, logging, health/readiness routes and small HTTP helpers. The TypeScript side is published as @capsizellc/commons. The first adopters included Capsize Online, joecurlee.com, the WXRQ admin surface and other Django sites. Each site kept its own application. They stopped maintaining separate versions of the same foundation.

The stack is deliberately boring: Python packaging, Django, a small TypeScript package, CI and trusted publishing. The technical angle is the adoption seam. A shared helper has to preserve the old site's behavior while making the next site easier to start. That means compatibility checks, a versioned health contract and a migration that can be reviewed one site at a time.

I can now fix a shared retry or settings bug once, publish a version, and update each site when I am ready.

The source is capsize-commons on GitHub. The public sites that use the pattern include capsize.online and joecurlee.com. The release context is in the Capsize four-week overview.

A practical adoption order

Start with one shared behavior that is easy to observe. Health and readiness routes are a good candidate because a smoke check can compare the old and new responses. Publish a small version. Adopt it in one site. Run the same check. Only then move the next site.

That sequence keeps a shared library from becoming a second monolith. The library owns the common contract. The application owns the reason it exists.

The first adopters are deliberately different. A project portal, a personal site and a radio admin do not have the same job, but they do need the same answer for health, settings and a few boring operational details. A shared package earns its place when that common answer gets easier to maintain without flattening the applications around it.

The package is small on purpose. It should remove repeated setup, not become the place where every application-specific choice goes to hide.

That restraint is what makes the next adoption reviewable.

How I built Capsize Online as a static Django site

w4ffl35 — Mon, 28 Sep 2026 15:15:02 +0000

I built Capsize Online to collect my public software, games and release notes in one place. I wanted Django for editing, but I did not need a live application server for pages that only change when I publish them. The site compiles the Django content into static files for production.

The site went live during the week with the shared Capsize shader identity and a tag-driven deploy path. The authoring database stays local. The production server receives the compiled output, not a running Django application. That keeps the public surface simple while leaving the content workflow pleasant to edit.

The output can live on any plain web server. Each tagged build also leaves a clear release and rollback point.

The site links AIRunner, SpikeForge, the Capsize Audio Visualizer, Capsize Games, WXRQ and my personal site. Its devlog can connect a project update directly to the repositories and releases behind it.

The live portal is capsize.online. The four-week release story is in Four weeks of building in public, with the technical project notes collected on DEV. The report links each public repository directly.

A small Django site pattern

Keep the content model small. A title, a slug, a summary, a body, a date and a publication status are enough for a useful devlog. Render the body to a static route during the build. Put the public images in the static tree and let the compiler carry them with the page.

This pattern works well for a project portal because the authoring experience and the deployment target have different needs. Django is a good editor. Static HTML is a good thing to serve.

The first version of the site was a list of links. The current version is closer to a small index of finished things: a project has a page, a release has a place to land, and a reader can move from a chart to the thing that produced it.

That is a modest job for a website, but it is a useful one. The portal does not need to explain every implementation detail. It needs to make the next click obvious and keep the project names, release pages and public work in one place.

Porting Cowboy Casino to VileEngine

w4ffl35 — Sun, 27 Sep 2026 15:15:01 +0000

I am moving Cowboy Casino into VileEngine, the C++ engine I use for retro games. Cowboy Casino is a small role-playing game about walking into a wild-west casino, learning the tables and trying to leave with more chips than you brought in.

The work is bigger than replacing one renderer. The casino is an overworld with rooms, doors, table scenes, dealers, save slots, character movement, dialogue and an ending. The native port now has the campaign map, collision and visibility layers, the table sessions, versioned persistence, converted art and new audio loops for the casino floor and boss table. The release build is the next milestone.

VileEngine supplies the C++23 runtime, SFML presentation, miniaudio, the CRT treatment and the editor tools around them. Cowboy Casino supplies the content and the rules. Keeping those responsibilities separate makes the port easier to test: the engine can improve its scene and audio work while the game keeps its own campaign state and table logic.

The original game is available on itch.io, and the public project map is on capsize.online. I will add the remake download there when the release build is ready.

What makes a port feel like the same game

The first pass is not the final screen. It is the return path. Walk from the casino to a table, finish a round, return to the same room, save, quit and load it again. If those transitions keep the wallet, position and campaign state intact, the port has a foundation. The visual polish can then move forward without hiding a missing game rule.

The next public milestone is the remake release. Until then, the itch page remains the right place for the original download and the repository is the right place for the engine work.

The port also gives VileEngine a real game to push against. A scene stack, an editor, audio and a CRT pass are easy to discuss in isolation. They become useful when a player can walk through a casino, sit down at a table, finish a round and return to the room they left.

That is the standard for the release candidate. The screen can change later. The game has to remember what the player did and bring them back to a place that still makes sense.

Building the Capsize Audio Visualizer with C++ and Qt

w4ffl35 — Sat, 26 Sep 2026 15:15:01 +0000

I keep coming back to the Capsize Audio Visualizer because it is small enough to finish. It is a C++ and Qt desktop application that turns live audio into shader-driven scenes, with controls for changing how the signal affects the picture.

This week it picked up CRT presentation work, floating mode, cross-shader audio mappings and three releases. The project is written in C++ and Qt with a native audio path and a collection of shader-driven scenes. The visual identity is not a web-only skin. The same shader language and palette now appear across the desktop app, the public site and the other Capsize properties.

Floating mode is a small feature with a large effect on how the application is used. The visualizer can sit beside another application instead of taking over the whole screen. Cross-shader mappings make the audio signal feel like one input to a set of related scenes rather than a separate toggle in every effect.

Try the public build at av.capsizegames.com or see the desktop edition on itch.io. The full four-week overview is on capsize.online.

A useful way to extend it

Pick one audio feature and map it to one visual parameter. Keep the mapping visible in the shader or effect configuration. Then add a second effect that responds to the same signal in a different way. The result is easier to tune when the signal path is shared and the visual differences live at the edge.

That is the balance I want from the project: a small program people can use tonight, with enough structure that the next visual idea has somewhere to go.

The public build makes the idea easy to test. Start a track, put the window beside another application, change the mapping and watch the same signal move through a different scene. If the effect needs a paragraph before it makes sense, the effect probably needs another pass.

The release work also keeps the boring edges in view: a local queued build, a repeatable package and a public page that explains what the download is. A visual tool gets better when the distance between changing a shader and trying the result stays short.

WXRQ turned a production kit into a radio station

w4ffl35 — Fri, 25 Sep 2026 15:15:02 +0000

I started WXRQ as a new repository for an automated radio and television station. Within a few days it had a public player, a schedule and a production path from written script to an HLS stream.

The production kit writes and checks a script, renders several voice takes, chooses a take for each line, adds a music bed, schedules the result, encodes it and sends it through HLS. The television channel has its own transport. The public site shows the player and schedule. The admin lets the production work be browsed and edited. The lecture pipeline turns CC BY textbooks into narrated courseware, so the station is not limited to one kind of show.

The stack is a mixture of Python, Django, Chatterbox, LMMS, NVENC and a small web player. Each tool has a job. The script gate catches problems before a voice is rendered. The voice path can compare several takes instead of accepting the first file that came back. HLS gives the public channel a normal streaming surface rather than a private development endpoint.

The station reached 0.6.13 during the week. You can listen, see what is on air and check the schedule at radio.capsize.online. The wider release story is on capsize.online.

Build a small show

Start with one short segment. Give it a beginning, a change and an ending. Run the script checks before you touch the voice pipeline. Render more than one take only when the line needs it, then keep the chosen take next to the script and the reason for choosing it. Add a bed that supports the scene instead of competing with it.

That small loop is enough to learn the system. After that, add the schedule and the public player. A station becomes a product when someone outside the repository can find the show, hear it and know what comes next.

The station is still small, which is exactly why the pieces are easy to see. A script is an input. A chosen take is an artefact. A schedule is a promise about what a listener will hear. The public player is where all of those decisions meet.

AIRunner is becoming a set of tools instead of one giant tree

w4ffl35 — Thu, 24 Sep 2026 15:15:01 +0000

I had let AIRunner, my open-source desktop AI application, do too much in one repository. The split is now visible in four public packages: airunner-eval, airunner-tts-vendor, airunner-native and airunner-common.

The names describe the boundaries. The evaluation package can process models without dragging the application into the run. The TTS vendor fork can be tested and published without importing the host application's database. Native tools can stay close to their sidecar binaries. Shared request and response payloads can be versioned once and consumed by the desktop and service layers.

The web engine moved in the same direction. It stopped naming the products it hosts, moved the world and economy layer into uwuchat-worldsystems, and renamed the service package to airunner_engine. The remaining boundary is visible in the code instead of being a convention in a README. That matters when a new application is added because the engine has fewer reasons to know it exists.

The stack is still familiar: Python, PySide6, HTTP and WebSocket services, package publishing and CI checks. The work was less about picking a new framework and more about making the existing contracts explicit. Import boundaries run in CI. The desktop/daemon contract has a version. Shared LLMRequest and LLMResponse payloads live in airunner-common instead of being copied between packages.

The user-facing site is airunner.art. The four-week release overview covers the other projects that moved alongside it.

The payoff is visible when a new change arrives. A model-evaluation change can stay in the evaluator. A native sidecar change can stay with the sidecar. The desktop app can consume a versioned payload instead of reaching into a folder that happened to be next door. Those are small boundaries, but they remove a lot of guesswork from the next release.

Why extract a package?

Extraction is worth doing when the package has its own reason to change, its own tests and a public consumer that should not install the rest of the application. If those things are not true, a new repository is just another place to forget to update.

The next AIRunner step is to keep the service boundary just as clear as the first four extractions. The goal is a smaller set of packages that can be installed and released independently while the desktop application still feels like one thing.

Build a small event-driven classifier with SpikeForge

w4ffl35 — Wed, 23 Sep 2026 15:15:02 +0000

I like to learn SpikeForge by giving it a small job and keeping the moving pieces visible. This walkthrough uses the public toolkit, a short experiment and the event path that gained a real train/test split in the latest release cycle.

Start with the SpikeForge repository and install the package in a fresh environment. Pick one of the example datasets already supported by the project. Keep the first run short. A small experiment that you can rerun is more useful than a large run that leaves you guessing about which setting changed the result.

The shape of the experiment is straightforward:

Load the dataset and turn the samples into the event representation.
Split the samples before training, so the test set stays out of the update loop.
Choose a compact network and a short number of epochs.
Save the configuration beside the result.
Compare the test output with the training output rather than reporting one number alone.

The train/test split is the important detail. It keeps an event-driven experiment honest when the model is changing quickly. The same configuration can then move through a target adapter or into the SpikeForge model hub with a name, version and small amount of provenance.

SpikeForge is built around Python, PyTorch and snnTorch, but the useful interface is the experiment boundary. You can change the model without changing the dataset loader. You can add a target without rewriting the training loop. That is why the project was split into packages rather than kept as a single directory with a longer README.

What to record

Record the dataset, event conversion, seed, model name, number of epochs and the exact package versions. Put those beside the output rather than in a notebook cell that will disappear. If you publish the result, include the short configuration and a link to the source. Small habits like this make the next experiment faster because you can see what actually changed.

The SpikeForge project page has the current package and dashboard links. I also wrote a four-week Capsize overview with the release context and the other projects that moved at the same time.

SpikeForge Dashboard gives the experiment a desktop home

w4ffl35 — Tue, 22 Sep 2026 15:15:09 +0000

SpikeForge Dashboard is the desktop interface for experiments made with the SpikeForge spiking-neural-network toolkit. Its desktop builds moved through 0.2.5 and 0.2.6 after a run of smaller releases that established the packaging path.

The dashboard exists for the part of the work that is awkward in a terminal: looking at an experiment, checking what was loaded, and keeping the result close to the configuration that produced it. It is a React and TypeScript dashboard packaged as a desktop application and backed by the SpikeForge packages. The app is not a replacement for Python. It is a visual surface for the same experiment.

The release work focused on the boundary between source code and the thing a user downloads. The build now has a package path, a desktop bundle, smoke checks and a small release checklist. The source tree can be green while the archive has the wrong files, the wrong path or a missing licence. The packaged archive is part of the test target.

The source is public in the SpikeForge Dashboard repository. The project site is spikeforge.net, and the desktop build is available through Capsize Games on itch.io.

I wanted the app to feel like a place for the experiment rather than a launcher with a screenshot attached. That means the current run, the loaded data and the path back to the source should stay near each other. It also means the release archive gets opened and checked as an archive, not only built as a side effect of the CI job.

A good first use

Install the desktop build and open one of the small examples from the core toolkit. Keep the experiment short, then compare the training and test views. If the result is worth keeping, move the configuration into the repository or the model hub instead of leaving it inside a screenshot.

This is the pattern I want from the desktop projects: a finished surface, a public download and a clear route back to the code. The next release can improve the surface without hiding how the experiment works.

The broader four-week release story covers the other software, games and sites that moved at the same time.

SpikeForge grew into a toolkit, a model hub and a dashboard

w4ffl35 — Mon, 21 Sep 2026 21:21:52 +0000

SpikeForge is my Python toolkit for building and testing spiking neural networks. It stopped behaving like one big project during this release cycle: the core toolkit, target adapters, model hub and SpikeForge Dashboard all moved forward as separate packages and applications.

The core project released 0.4.0 and 0.5.0, then kept publishing the smaller package releases that make the ecosystem usable. The event path got a real train/test split. Quantization work moved into the drift checks. Shared logging came from capsize-commons, and the CI path gained a fast leaf lane for the parts that do not need the whole workspace.

The package layout is now a practical map of the work:

spikeforge holds the training and experiment workflow.
spikeforge-targets holds target-specific conversions.
spikeforge-hub owns the offline-first model catalogue.
spikeforge-dashboard contains the web dashboard and desktop application.

That separation is useful, not just a tidy repository list. Someone experimenting in Python does not need to install the desktop app. Someone browsing models does not need the server. Each piece can ship when it is ready, with compatibility recorded instead of implied.

The stack is Python, PyTorch and snnTorch around the core, with a web dashboard and desktop application around it. The model hub is deliberately cache-friendly, so a catalogue can be inspected and used without turning every experiment into a network operation. SpikeForge Dashboard gives the same work a visual entry point and provides a place to inspect the experiment rather than only its final number.

The project page has the current package links and release notes: spikeforge.net. The desktop releases are collected on itch.io, and the source is on GitHub.

A small experiment to try

Install the core package, choose one of the examples, and keep the first run small. Start with one dataset and a short training window. Then move the same experiment through the target adapter and save the result in the hub catalogue. The point of the exercise is not a leaderboard number. It is seeing the path from an experiment to a named, repeatable artefact.

A follow-up article walks through a small event-driven classifier. The four-week overview covers the rest of the Capsize work from the same period.