##### ##### ##### #####
# # # # # {*}
# # # # ## #####
# # # # # #
##### ##### ##### #####
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 Apple II has come a long way: accelerators, storage by the gigabyte, RAM disks, and sharp modern video. The one thing none of it can fix is the modern web, 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 Apple. It can just finally talk to the world. One card, any Apple II: the same board drops into a slot in the ][+, the //e, or the IIGS.
]PRINT "HELLO (MODERN) WORLD!" HELLO (MODERN) WORLD! ]
The community already solved the hard upgrades on the Apple II:
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 1 MHz to 2.8 MHz CPU. It has been solved before, and solved well: purpose-built hardware has terminated TLS on the device for vintage machines for years, and offloading the hard cryptography is exactly the right call. CoGS makes that offload a slot-native co-processor: purpose-built for the Apple II bus, with the speed, low latency, 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.)
CoGS does not just fetch data, it serves whole disks. Give it a link to a disk image, on your own network OR anywhere on the internet, and your Apple sees a real drive: it boots from it, runs from it, and writes back to it, with nothing installed on the machine. The card answers SmartPort and ProDOS block calls straight out of its ROM, so the drive is there the moment the machine powers on, the trick the community loves from cards like the CFFA, now coming off the network instead of a local chip. The link can point at a folder shared off your Mac or at a file out on the web: the card does DNS, TCP, and TLS itself, so an https:// URL mounts exactly like a LAN one.
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:
For developers. CoGS is not a black box. The building blocks are open: a documented protocol that runs over the slot, plus client code so your program can open a connection, fetch over HTTPS, hash data, or pull true randomness in a few calls. Flow: your app (6502 / 65816) to CoGS (TLS, HTTP, JSON, hash, RNG, nonce) to the modern web over Wi-Fi and TLS. Protocol spec and client library/headers go up on GitHub (coming soon). Example apps today: github.com/rperissi (GS Miner, GS LLM).
Develop without the hardware. A virtual CoGS card runs inside the Ample emulator (and MAME), so you can write and test apps with no card on your desk. It links the same firmware core the real card runs, with live networking through your Mac (DNS, TCP, HTTP, JSON) and a LAN bridge so Marinetti and IP65 software reach the real network. One command sets it up, and the same binary then runs on real hardware. TLS and HTTPS happen on the card's crypto, so in the emulator use plain HTTP or a local TLS proxy.
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: the modern internet's cryptography simply can't run on a 1 MHz 6502 or a 2.8 MHz 65816. There are already good answers to that. Some run the real program on another computer and leave the Apple as a terminal. Others, like the excellent FujiNet, put a dedicated device on the disk port that has been terminating TLS for vintage machines for years, with the Apple still running the show. Offloading the hard cryptography is the right idea, and CoGS stands squarely on that prior art. What I wanted was a different shape for it: not a helper beside the machine but a true card inside a slot, bus-native, mapped right into the machine so the program can call it in a few register writes. The Apple still owns the program, the screen, and every decision. The card just does the parts the silicon of 1986 never could.
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).
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, and the newest chapter, whole disks served over the network, streams on real hardware with every image in the 519-disk index boot-tested (firmware 0.48), verified on stock and accelerated machines alike.
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 runs on parts you can already get: an A2Pico Multi-Function Card (open Apple II card, available at JCM, https://jcm-1.com/product/a2pico/) plus a Raspberry Pi Pico 2 W for Wi-Fi (from Amazon or any retailer). The purpose-built CoGS card, with extras like wired Ethernet, is coming soon.
Note: A2Pico boards come with a Pico W; you'll need to desolder and solder on a Pico 2 W for Wi-Fi. We are working with JCM (Joe's Computer Museum) to stock a CoGS-ready board with the Pico 2 W already fitted, so you can skip that. The open-source firmware and software, with a repo and downloads, go public soon.
Open source, open hardware, a community project.
For the Apple ][ · ][+ · //e · IIGS
An Apple II card, at home in any slot.
Copyright 2026 CoGS project.