Your classes, deadlines, grades, and knowledge, organized into one calm academic workspace.
Your degree runs on Canvas, Workday, some calendar app, and whatever chat window you open when you're stuck at midnight. None of them talk to each other. UniVerse pulls them into one macOS app and puts an assistant on top that has already read your syllabus.
And, it can work with any LMS, not just Canvas and Workday, the two most common ones.
It runs on GPT-5.6, stores everything locally in SQLite, and has no server, no account, and no telemetry.
Download for macOS (Apple Silicon) →
We're two students at Washington University in St. Louis. Every semester we watched ourselves and our friends do the same tedious loop: open Canvas to see what's due, dig through the syllabus PDF to work out whether it's worth 5% or 30%, open Workday in another tab to check whether the class you need next term has a prerequisite you haven't taken, then paste a problem into ChatGPT and burn the first three messages explaining what course you're even in.
None of that is studying. It's manual data entry between systems that a university already pays for, and every student does it from scratch, every week.
The tools that exist pick one side of the problem. LMS front-ends make Canvas prettier but stop at the due-date list, because that's where the API stops. AI study tools answer well but have never seen your course, so you feed them the same context over and over. Nobody joins the two up, which is the only thing that would actually help.
UniVerse started as something for us and our friends at WashU. The problem isn't specific to WashU though, so we built it to generalize: every school integration sits behind an adapter, and adding one doesn't touch anything above it.
Uni is the assistant, and it's the reason the rest of the app was worth building.
Uni reads your actual course materials. When you retain a class, UniVerse scans its syllabus, modules, pages, announcements, discussions, assignment descriptions, and attached files, then turns all of it into searchable passages stored on your machine. Scanned PDFs with no selectable text get rendered page by page and run through a local OCR model.
So when you ask Uni something, it answers from your professor's material and cites which file it came from. There's nothing to upload and no context to re-explain, because the app already has it.
Uni shows up where you're already working rather than sitting in a separate chat tab:
- Ask Uni on any course page, with that course's material already loaded
- Review with Uni from Grades, on whichever class is slipping
- Prioritized by Uni on Home, ordering your week from real deadlines and weights
- Study Lab decks, quizzes, summaries, and study plans, all built from the same grounded context
Your real Canvas (or other LMS) courses, synced. Sign in through your school's flow. Courses, weighted grade breakdowns, assignments, and deadlines come across, and later syncs only re-read what actually changed.
A registration planner that reads your degree audit. This is the part no other student tool does. UniVerse signs into Workday, reads your real degree audit, works out which requirements you still haven't satisfied, and recommends next-term courses against those specific gaps. It then ranks possible schedules by time of day, how compact your days are, and conflicts. Uni never invents a course here: candidates come from the live catalog, and anything it suggests that isn't on that list gets dropped.
Grades that tell you where to spend the week. Ranked by what actually moves your GPA, using the real weighted breakdown from Canvas rather than sorting by due date.
Study Lab. Flashcards, summaries, and quizzes generated from your own course material, not a generic version of the subject.
Calendar export that doesn't make a mess. Send assignments, exams, and study blocks to Google
Calendar, Apple Calendar, or Outlook as a standard .ics file. Every event carries a stable ID, so
re-importing an updated file revises what's there instead of creating duplicates.
Focus mode. A timer tied to a specific assignment, with a native macOS helper that hides everything else while you work.
Full detail on how each of these works is in docs/FEATURES.md.
Not a student, or don't want to hand a school account to an app you just downloaded? Pick "Sample semester" on first launch. No sign-in, nothing to configure.
You get six courses with weighted grade breakdowns and graded work, a week of deadlines including one that's already overdue, and pre-built study decks. Home, Grades, Calendar, and Study Lab are populated the moment you land. Add an OpenAI key and Uni works on that sample semester too.
This is the fastest way to see the whole app, and it's what we'd point anyone evaluating it at first.
Download the latest .dmg, open it, drag
UniVerse to Applications. There's a .zip of the same build on the release page.
Our builds aren't signed yet, since that needs an Apple Developer certificate, so macOS will refuse to open it the first time. Right-click the app and choose Open, then Open again in the dialog. Or go to System Settings → Privacy & Security and hit Open Anyway next to the notice. After that it launches normally.
Running from source, building your own .dmg, and the current state of Windows and Linux are all
covered in docs/BUILDING.md.
Uni runs on OpenAI, using gpt-5.6-luna by default. Put your key in the OS keychain:
npm run configure:openaiThe main process also reads OPENAI_API_KEY from the environment. You can change the model in
Settings.
If you can't afford an API key
We're students. We weren't going to ship something a classmate couldn't use because they didn't
have a few dollars for API credits. If there's no key configured, UniVerse looks for a local model
server (Ollama on 127.0.0.1:11434) and uses it automatically, with no setup inside the app.
The quality gap is real, and we'd rather say so than pretend otherwise. Grounding carries a lot of it, since even a small local model does much better when you hand it the actual syllabus. But GPT-5.6 is clearly sharper on the work that needs reasoning: study plans, quiz generation, and course recommendations. Use a key if you can.
The first working version of UniVerse came out of Codex: the Electron main process, the typed React renderer, the preload bridge, and the persistence layer. Empty directory to an app running on screen.
That's the part that mattered most, because getting to a running app is where projects like this usually die. Between "we want a local-first academic workspace" and "there's a window on screen with my real data in it" sits a pile of scaffolding — process boundaries, IPC contracts, build config, bundler wiring, a database schema — that has to exist before you can write a single feature anyone would notice. Codex cleared that in one pass and put the boundaries in sensible places while doing it.
All ~26,500 lines in this repo grew from that starting point. The ownership rules we still work
under come from it: the renderer never touches Electron, SQLite, Node, or session cookies; document
extraction and OCR stay in the main process; Canvas-specific objects never leak into shared UI
contracts. Those rules are written down in ARCHITECTURE.md and
AGENTS.md, and they're why two people building around a course load still have a
codebase we can add to instead of one 4,000-line App.tsx.
They're also what makes other schools tractable. Because each integration sits behind a fixed
interface, adding an institution is a self-contained job with a typed contract on one side and a
real system to read on the other, checkable with npm run typecheck, npm run build:app, and a
smoke test. That shape suits an agent well, and the Canvas and Workday work went a lot faster for
having Codex on it.
We used GPT-5.6 to work out what UniVerse should be. The most useful thing to come out of that was deciding early that the hard part wasn't the chat box, it was everything upstream of it. That kept us from building another wrapper with a file-upload button, and it decided a lot of what we cut.
It also made the visual identity. The UniVerse mark, the orbit with the U in it, and the macOS app
icon were both generated with GPT-5.6, along with Uni's own mark. A default Electron icon tells
anyone opening your app exactly how seriously to take it, and we didn't want that. The design
language came out of the same work: the frameless window, the background materials, the decision to
give every major surface its own component and stylesheet instead of one enormous file. We wrote
those into AGENTS.md as constraints so they'd survive later changes.
And GPT-5.6 is what Uni actually runs on. Every grounded answer, deck, quiz, study plan, and course recommendation in the app is GPT-5.6 working over a student's real coursework.
| docs/FEATURES.md | How each part works: the Knowledge Base, Uni, the registration planner, calendar export, and what happens to your data |
| docs/BUILDING.md | Running from source, tests, building the .dmg, Windows and Linux |
| docs/ROADMAP.md | What's limited today, adding your school, what's next |
| ARCHITECTURE.md | Dependency map and module boundaries |
| AGENTS.md | Contributor and agent constraints |
Two students built this around a full course load, and it's early. It does real work, but you should know what you're getting.
It's wired to one school so far. Canvas points at wustl.instructure.com by default, which should
adapt to another Canvas school by changing the domain during onboarding. The Workday side reads one
specific tenant's degree audit and won't survive being pointed at a different one without work.
macOS on Apple Silicon is the only build we ship. Windows and Linux can run from source with a few changes, most of which we've listed out.
Builds are unsigned, so you'll hit the Gatekeeper prompt above.
The full list, and what we're doing about it, is in docs/ROADMAP.md.
Issues and pull requests are welcome. Read ARCHITECTURE.md and
AGENTS.md first, and please don't commit real course data, session cookies, or API
keys.
Apache License 2.0. See NOTICE for attribution.