Co-Processor for the Apple II

The missing
Link.

Your IIGS has acceleration, vast storage, stereo sound, modern display output, and inexpensive memory for huge RAM disks. The perfect GS — except it cannot reach today's internet, because the modern web is locked behind TLS 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, 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.

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 GS

  • Acceleration many times faster than 1986
  • Storage vast, instant, silent
  • Sound stereo beyond the stock Ensoniq
  • Memory inexpensive, with huge RAM disks
  • Display clean output to a modern panel

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

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

The 8-bit family, too

GS-first, not GS-only. An IP65 driver brings the same modern internet to the slotted 8-bit machines, and a client library (cc65/ca65, ProDOS 8) lets new //e and ][+ software talk to the card directly. A slot is a slot; so is CoGS.

An Apple //e reaching the modern internet through CoGS
An Apple //e on CoGS, second view
Planned

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.

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 GitHub (coming soon) Spec & docs on GitHub (coming soon) Contributing guide on GitHub (coming soon)

How can I get one?

Built to run on hardware you can already get.

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. The purpose-built CoGS card, with extras like wired Ethernet, is in development.

The board

Build My Own What parts do I need? Order Prebuilt DIY coming soon

Software & the card

Firmware Download coming soon CoGS Card in development · see roadmap
Notify me / Questions

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 the GitHub repo and downloads, go public soon.