Co-Processor for the Apple II

The missing
Link.

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, and hardware hashing, handing 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.

See what it does The code & spec

Ethernet/Wi-Fi/TLS/SHA‑256/TRNG/Clock

CoGS card concept render: matte black PCB with gold edge connector, a Pico Plus 2 W (RP2350B) with CYW43439 Wi-Fi, a W5500 and RJ45 Ethernet jack, three 74LVC245A bus transceivers, micro SD, USB-C, and LINK/ACT LEDs. Designed by Rob Perissi, based on the open-source A2Pico project.

Concept render. The custom card (M7) is a later milestone; today CoGS runs on a Raspberry Pi Pico 2 W fitted to an open A2Pico carrier.

The gap

The hard upgrades are solved. The modern web still isn't slot-native.

Already solved on the Apple II

  • Acceleration many times faster than stock
  • Storage solid-state, instant, silent
  • Memory cheap RAM and huge RAM disks
  • Display clean output to a modern panel
  • Sound sound cards well past the beep

Each upgrade follows one quiet rule: more capable, still itself.

The part still missing

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 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.

What it does

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.

Secure web

Your Apple II talks to real HTTPS APIs directly. The card runs the whole TLS handshake and verifies the certificate; the host only ever sees plaintext.

Desk-verified

JSON, without parsing JSON

Ask for choices[0].message.content and the card returns just that value out of a whole API response. A 64 KB machine never touches a parser.

Desk-verified

True random numbers

Real entropy from hardware silicon. No Apple II ever shipped with a hardware RNG. Now yours has one.

Desk-verified

Hardware hashing

Single and double SHA‑256 in dedicated silicon, for the cost of a few register writes. Checked byte-for-byte against the reference.

Desk-verified

A real hardware miner

Hand the card a block header once; it grinds nonces locally at roughly 2400× a stock GS and returns the winner. Your GS keeps running the protocol and the UI.

Desk-verified

Your modern NIC

Wi-Fi out of the box, wired RJ45 on the custom card — plug and play. In bridge mode your Apple II gets its own IP and is a real host on the LAN, so Marinetti and IP65 software just works, now with co-processing behind it, carrying your Apple into the 21st century.

Wi-Fi live, bridge working

A clock

The card runs NTP for secure time anyway, so it can set your machine's clock. For everyone whose No-Slot Clock battery died decades ago.

Time synced

Card vitals

The card reports its own health: on-chip temperature, the slot's +5V rail (a free read on your host power supply), uptime, a unique serial, and why it last booted. It answers even with Wi-Fi down, and shows up live in the desktop control panels.

New in firmware 0.8

Native to the machine

It feels like part of your Apple. Because it is.

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.

CoGS Control Panel on the GS

Set up and watch the card right from the machine, no serial cable and no guesswork. One on-card configuration, three faces, so a change in one shows up in the others — in whichever place suits the moment:

  • Control Panel (CDev) — the first-class config home, right next to TCP/IP and Time. Scan for nearby networks and pick one, join Wi-Fi, run a live connection test, set your time zone and auto-sync the clock, and see your network at a glance (SSID, IP, subnet, gateway, DNS, MAC).
  • Status (NDA) — a thin live-status window in the Apple menu that floats over any app: link, IP, signal, the full network read-out, and the clock, updating as you watch.
  • Config Console (CDA) — the bare-metal rescue tool, reachable with Ctrl‑⌘‑Esc even on a half-booted machine. Scan and pick a network, bring Wi-Fi up, and set the clock when nothing else will.
The CoGS control panel sitting in the GS Control Panels list
CoGS Control Panel (CDev): status, networking, clock, and Wi-Fi join
CoGS Status (NDA): live link, IP, card vitals, and clock floating over the desktop
Apple-menu Desk Accessories, with the CoGS Config Console ready to open
CoGS Config Console (CDA): firmware v0.8, link, IP, and card vitals at a glance
Connectivity test: plain HTTP and verified HTTPS — the card does DNS, TCP and TLS itself
Clock: network time, auto-synced when Wi-Fi connects
Wi-Fi scan: nearby networks with signal strength and security
Working on hardware

Marinetti GS Link Layer

A native link-layer driver so the whole Marinetti TCP/IP ecosystem runs over CoGS. In bridge mode the GS gets its own IP and is a first-class host on your LAN, so every existing Marinetti app — mail, web, IRC — just works, unchanged.

Marinetti TCP/IP Setup, with the Link layer set to CoGS
CoGS Link Layer config: DHCP, IP, subnet, gateway, DNS, MAC, and MTU
Working

Every Apple II, not only the GS

A slot is a slot. The same card on the same open A2Pico carrier runs in the ][+, the //e, and the IIGS. The desktop software above is the GS side; for the 8-bit machines an IP65 link layer and a cc65 / ProDOS 8 client library carry the same modern internet to new and existing software.

An Apple //e reaching the modern internet through CoGS
An Apple //e on CoGS, second view
8-bit software in progress

What it unlocks

So what can my Apple do now?

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.

On our list

Talk to AI

LLM chat (already in flight), an AI dungeon master for text adventures, on-the-fly translation, or a button that summarizes any web page to the screen.

Live data, on the desktop

Weather, stock tickers, sports scores, headlines, transit times — pulled fresh from real APIs into a desk accessory.

Real messaging

Email over genuine TLS, IRC and chat bridges, a Mastodon client, an RSS reader. The GS back on the live network.

On our list

Mining & crypto

The hardware nonce scanner for Bitcoin (our miner is getting the upgrade), plus hashing utilities and a password vault seeded by true randomness.

Cloud & sync

Pull files and updates from a web server or GitHub, back up to the cloud, fetch fresh disk images on demand.

Play with the world

Post high scores to an online leaderboard, turn-based multiplayer, daily shared puzzles delivered over the wire.

Secure by default

TOTP two-factor codes (the card keeps real time), signed requests, and downloads that are certificate-checked on the card.

Whatever you dream up

It is a slot card with an HTTPS pipe and a toolbox. This community has always done the rest. Possibilities are endless.

For developers

Build your own app for the card

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. Call it an API if you like, but the point is the opposite of a cloud service you rent. The card is right there in the machine, and it is yours.

Protocol spec on GitHub (coming soon) Client library & headers (coming soon) Example apps on GitHub
Designed for CGS

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.

The constraint

Apple II Forever.

We mean it as an engineering constraint, not a slogan.

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.

The story

It started with apps, not a card.

It began with building things for these machines: a Bitcoin miner, then a modern LLM chat client 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, and the secure stack now runs on a real GS in a slot:

  1. M0

    Echo

    ID/VERSION + DATA loopback, GS presence test.

    On hardware
  2. M1

    Frames

    Ring buffers, frame parser, PING/STATUS.

    On hardware
  3. M2

    Radio

    Wi-Fi scan & join (auto auth), NTP time, plaintext TCP with DNS.

    On hardware
  4. M3

    TLS

    TLS 1.2, curated CA bundle, one-shot HTTP/HTTPS.

    On hardware
  5. M5

    Card services

    HASH, RANDOM, JSON_GET, NONCE_SCAN.

    Desk-verified
  6. M6

    Apple II family

    8-bit client library and a IIe demo.

    Ahead
  7. M7

    Custom card

    Own PCB, optional wired Ethernet, a small community batch.

    Ahead
6card services live
~48kH/s SHA‑256 miner

Demos

Here is why this was impossible yesterday.

Screen captures land as the milestones do.

A IIGS holding a conversation with an LLM, tokens streaming in — no Mac anywhere on the LAN.
True hardware randomness painting unpredictable noise on a GS screen.
The miner's hashrate counter ticking while the rest of the machine stays responsive.
Hardware day: the card into a real slot, the first PING response.

Built on shoulders

Open source. Open hardware. Community.

A2Pico

The open bus-interface platform by Oliver Schmidt (firmware, MIT) and Ralle Palaveev (hardware) — the genuinely hard part of meeting Apple II slot timing. CoGS builds directly on it.

FujiNet

Proved TLS, HTTPS, and JSON offload for vintage machines years ago. Its JSON device directly inspired JSON_GET. Prior art we respect.

Marinetti & ORCA/C

Marinetti, ORCA/C, and Golden Gate keep the IIGS programmable in 2026. CoGS bridges into the Marinetti ecosystem so existing software just works.

Build the firmware

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. Source, spec, and clients go up on GitHub at launch.

cd firmware && cmake -B build -G Ninja \
  -DPICO_BOARD=pico2_w -DCMAKE_BUILD_TYPE=Release
cmake --build build   # -> cogs.uf2
Source on GitHubcoming soon Spec & docs on GitHubcoming soon Contributing guide on GitHubcoming soon

How can I get one?

Built to run on hardware you can already get.

CoGS runs on parts you can already get: an open A2Pico carrier (the proven Apple II slot card) with a Raspberry Pi Pico 2 W on it for Wi-Fi. The purpose-built CoGS card, with extras like wired Ethernet, is a later milestone.

The board

A2Pico Multi-Function Card Available at JCM Raspberry Pi Pico 2 W the Wi-Fi brain

Note: A2Pico boards come with a Pico W. You'll need to desolder it and solder on a Pico 2 W for Wi-Fi.

The software

Firmware Download coming soon CoGS Card purpose-built · coming soon

Open source: the firmware, software, repo, and downloads go public soon.

Notify me / Questions

Want a CoGS-ready board the moment it is listed? Ask, or get a ping when it goes live.