##### ##### ##### #####
# # # # # {*}
# # # # ## #####
# # # # # #
##### ##### ##### #####
CoGS · Co-Processor for the Apple II
You are reading the plain-text edition of the CoGS site, served with no stylesheets, no scripts, and no images, so that ancient browsers (and text browsers like Lynx) can render it just fine. It is also a small tribute to projects like 68k.news that keep the vintage web reachable. The full graphical site lives at index.html.
Your IIGS has acceleration, vast storage, stereo sound, modern display output, and inexpensive memory for huge RAM disks. The perfect GS, except for one thing: it cannot reach today's internet, because the modern web is locked behind TLS that no 6502 or 65816 can reasonably run.
CoGS is the key. A single slot card that does the impossible parts ON THE CARD (TLS, HTTPS, JSON, true random numbers, hardware hashing) and hands your Apple II plaintext. The machine stays in charge of everything else. It is still your GS. It can just finally talk to the world. Built GS-first, the same slot card is headed for the //e and ][+ next.
The community already solved the hard upgrades on the GS:
Each follows one quiet rule: more capable, still itself. The part still missing is the modern SECURE internet, in a slot. Every useful API is HTTPS now: certificate chains, key exchange, X.509 parsing, a handshake state machine, then JSON on top. That is not a "needs more megahertz" problem; it is months of fragile cryptography with no business on a 2.8 MHz CPU. It has been reached before, brilliantly, from outside the machine. CoGS does it slot-native: purpose-built for the Apple II bus, with the speed, direct memory access, and on-card co-processing only a slot makes possible.
A network card and a co-processor toolbox. Every service is a job the host genuinely cannot do, or would be absurd to ask of it. Everything else stays on the Apple II.
A client can probe one card and adapt: the PING response carries a capability bitmap. A current build reports all six services live.
Hardware is only half of it. CoGS is built to disappear into the Apple II you already know: configured from the desktop, and wired into the network stack the community already uses. (The desktop config faces and the Marinetti link layer are working on real hardware; the 8-bit path is on the roadmap.)
With a secure link to the modern web and a co-processor on board, the question stops being "can it?" and starts being "what will you build?" A couple of these are ours to finish; the rest are possibilities, most of them yours to write:
Designed for CoGS. A mark we want to offer for software built to use the card, so apps that light up your Apple II with modern powers are easy to spot: the seed of a full suite of modern Apple II software, written by the community, running on the machine itself.
CoGS refuses to become the brain. It would be easy, and wrong, to build a card that runs the program on its own fast processor and hands the Apple II a finished picture. That is not an Apple II anymore. That is a modern computer in a beige case.
CoGS is a co-processor. It does only the work the machine genuinely cannot: it terminates TLS, it hashes, it makes true randomness, it walks JSON, it grinds nonces. In every case the Apple II decides what to ask for, runs the program, and owns the screen and the user. The card is a tool on the bench, not a hand on the wheel. We mean Apple II Forever as an engineering constraint, not a slogan.
It started with apps, not a card. It began with building things for these machines: a Bitcoin miner (github.com/rperissi/iigs-bitcoin-miner), then a modern LLM chat client (github.com/rperissi/iigs-llm) for the Apple IIGS. Each one ran into the same wall: to reach the modern internet, the real work had to live somewhere off the machine, a helper on another computer or a clever external device. Those approaches are good, and some are excellent. But the goal here was different: keep the work on the Apple itself, slot-native, with full speed and direct access to the bus.
What made it feasible was modern tooling. Designing the protocol, writing the firmware, and bringing up the clients with AI-assisted development in Cursor turned what would once have been years into an iterative, almost playful loop: sketch an idea in the morning, have it answering on real silicon by the afternoon. That speed is the point. It unlocks the imagination to actually ship working software for a forty-year-old computer.
So much of the hard groundwork was already laid by this community, the bus interface, the TCP/IP stacks, the toolchains, that the next step felt obvious: build one card that drops into any slotted Apple, with a whole suite of capability on board, to empower the next wave of software and keep our favorite computers alive long into the 21st century (and beyond). From there it was built and tested one honest layer at a time, each proven before the next.
Contact with real silicon rewrote parts of the spec, exactly as it should. Today the full secure stack and all six card services run and pass their tests on the bench.
By the numbers: 6 card services live; SHA-256 miner measured at about 48 kH/s.
It runs today on a Raspberry Pi Pico 2 W fitted to an open A2Pico carrier. The protocol lives in a written spec that the firmware follows, with docs that walk through how it all works.
cd firmware && cmake -B build -G Ninja \ -DPICO_BOARD=pico2_w -DCMAKE_BUILD_TYPE=Release cmake --build build (produces cogs.uf2)
CoGS is a DIY platform first. The firmware and software are built to run on easily obtainable parts: an open A2Pico carrier and a Raspberry Pi Pico 2 W (see "Build the firmware" above). The purpose-built CoGS card, with extras like wired Ethernet, is in development.
Prefer it ready to run? Pre-assembled DIY boards that support CoGS firmware and software will be available from trusted Apple II community vendors (coming soon). The open-source firmware and software, with a repo and downloads, go public soon. The custom CoGS card, with additional features, follows after that.
Open source, open hardware, a community project.
For the Apple ][ · ][+ · //e · IIGS
Designed for the Apple IIGS. Works on any Apple II.
Copyright 2026 CoGS project.