Skip to content

Academy

Optersoft Academy

academy.optersoft.com is where we prepare the workers: courses for the higher vocational cycles, for professionals who need to be current again, and for the non-technical staff who run a business and have outgrown Excel. Written by the people who use these tools in production.

The platform

Academy, the material every course is built from

Every course stands on the same corpus: the material vocational classrooms already use, taught at the versions we run in production. A person buys a programme; a centre buys it for a roster; a company buys seats for its own people.

  • The teaching platform every course we sell is built on, in English and Spanish.

    academy.optersoft.com
    • Rust
    • Markdown
    • Git as CMS
    • Two locales

    The constraint

    Teaching material goes stale silently — the page still loads, it is just wrong. A corpus this size has to be maintained like software: reviewed, versioned and translated with the drift visible. And a student should meet the page their syllabus points at, with a wall only where the programme is bought and never by surprise.

    What we built

    Pages are Markdown in a git repository, and whether a student may read one is decided by whether some programme's syllabus names it. Every translation records the commit and blob of the source it was made from, so a page that has drifted behind its original is detectable rather than merely suspected.

    Where it is

    Around 1,000 pages covering ASIX, DAM, DAW and IABD and the specialisation courses, in English and Spanish, a preview of each open to anyone. A person buys a programme from the page; a centre buys it for a roster, with the licence to teach with it; a company buys seats for its own people.

For the classroom

The programs a course assumes

A lesson cannot start until every machine in the room is the same one and every student has the same tools. Oxid is what the web material is written in; box and the Kotlin extension are small, free, and written for our own classrooms before anyone else's.

  • Full web applications in pure Python. No JavaScript, no bundler, no node_modules.

    oxid.optersoft.com
    • Python
    • Rust
    • WebAssembly

    The constraint

    A team that knows Python should not need a second language, a Node toolchain and a bundler to put an interface in a browser — and every one of those is one more thing a student has to learn before writing the first useful page.

    What we built

    A fine-grained reactive framework, and underneath it a Python runtime of our own: a bytecode virtual machine written in Rust, compiled to WebAssembly, with the reactive core as native types inside it — and, on the same runtime, the server that renders each page per request. Prerendering writes each route as finished HTML and the browser hydrates it, so a page with nothing interactive on it downloads no runtime at all.

    What it does for us

    It is what our web applications are written in and what Academy teaches web development with; the site you are reading is built with it, and not one of its pages fetches a line of JavaScript. Apache 2.0, on PyPI — pip install oxid is the whole install. It was called Frontage until October 2026.

  • Linux machines on a Windows laptop, from one command or from a desktop app.

    box.optersoft.com
    • Rust
    • WSL2
    • gpui

    The constraint

    A course needs more than one Linux machine per student — a server and a client, a network between them, one to break and one to rebuild — on Windows laptops we do not administer, and without a student having to remember a single wsl --import argument.

    What we built

    box makes a Linux machine from a distribution's official WSL image, provisions it — a user with passwordless sudo, the student's SSH key, the hostname — and opens a shell in it. One flat list of commands for the whole life of a machine, from create to compact to delete, and a desktop application beside it for the students who would rather click than type.

    What it does for us

    It is the machine under Academy's Linux, networking and systems material. Free to download, for Windows; it ships as a binary rather than as source.

  • JetBrains' Kotlin Toolchain in VS Code — module.yaml projects that resolve, on any machine.

    kotlin.optersoft.com
    • Kotlin
    • Rust
    • VS Code
    • Language server

    The constraint

    JetBrains builds the Kotlin Toolchain for IntelliJ IDEA and for nowhere else: the official Kotlin language server imports Gradle, Maven and Bazel projects, but not the toolchain's own module.yaml. And a classroom of eight-year-old machines cannot afford a heavy IDE, where every second of the edit-run loop counts.

    What we built

    A VS Code extension and the language server it bundles, written in Rust: completion, hover, go to definition, find all references and rename across a project, the toolchain's tasks from the editor, run on save and a new-project command. The parser, outline and formatter need no build at all, so the editor is useful the moment a file opens.

    What it does for us

    It is the editor under Academy's Kotlin material, and the guide there says what it can give you, what it cannot, and where the seconds go. Free to use, on the VS Code Marketplace, documented at kotlin.optersoft.com.

Why Academy exists

Companies need people who are competent in an environment that keeps changing, and once someone is inside a company there is no time to train them properly. A qualification says a programme was completed; it says little about what the person can do today, and everywhere the answer has been to ask for one more certification on top.

So Academy teaches what is needed now — the stack we build with, at the versions we run — so that the person is ready for the company. Where an official title exists for it, it comes from a partner centre authorised to award it. It is the same material for all three audiences, used with real students before it is sold.

Reading a preview of any page costs nothing. The programme is bought — by the person, by their centre or by their employer — and what it buys is the course material, the same for each of them.

Open Academy

What is on it

What does an Academy course contain?

An Academy course is built from around 1,000 pages of material covering the ASIX, DAM, DAW and IABD cycles and the specialisation courses: worked examples, exercises and a learning path through each subject. The material is mapped to the vocational-training curriculum, so a course can be taught from it rather than only alongside it.

The stack we build on

Python and Rust first — Oxid for the web in pure Python, hive under everything we run — plus Linux, networking, cloud, data, AI and security: the same ground our own products stand on, taught at the versions we run in production.

Is the material in Spanish?

Academy is written in English, with a Spanish translation of the pages the classrooms it serves need most. Every translation records the version of the original it was made from, so a page that has drifted behind says so instead of quietly going stale.

Who it is for

Three kinds of people a company needs, and a course for each. What differs is where each one starts.

Future IT talent
The higher vocational cycles — ASIX, DAM, DAW and IABD. The material for the cycle, taught at the versions we run. The official title comes through a partner centre.
Professionals retraining
The specialisation courses, for someone who already holds a title and needs to be current again — AI, the cloud, the stack the industry is moving to. The official course through an authorised partner, or our material on its own.
Non-technical staff
Run a business with AI instead of Excel: leave the spreadsheet for CSV files and a database, and run, check and keep working the code a model writes for you. You leave with an environment on your own machine that still works months later.

Who can buy an Academy course?

A person, a centre or a company, and all three buy the same material. A person buys one cycle-year or one specialisation course from the page itself, a centre buys the programme for its roster, and a company buys seats for its own people at the price a person pays. A preview of every page is open, so no student meets a wall by surprise.

A person
A programme, bought from the page itself: one cycle-year of material, or one specialisation course.
A centre
The programme for a whole roster, on one invoice, with the licence to teach with the material in class. Write to us and we set it up with the centre.
A company
Seats for your own people on any of the three courses, delivered on the platform, at the price a person pays. Taught days are the premium, not the default.

Why these languages

Academy teaches what we build with, which is the only reason we are qualified to teach it. Each of these is load-bearing in something we ship.

Python
Web applications in pure Python with Oxid, tooling, data work and automation — including the command runner our own repositories are built with. The language most students meet first, used the way it is used at work.
Rust
Every backend we run and the serving infrastructure underneath them. It is what we reach for when a thing has to keep running unattended and be cheap to operate.
AI
Not as a subject but as the way work gets done: running, checking and keeping the code a model writes, and agents inside the workflow. Most of our own work goes through it, and the course for non-technical staff is built on nothing else.
Linux and cloud
The machines all of it runs on. Our fleet is a handful of Linux VMs we operate ourselves, and the Linux, networking and cloud tracks are written from that.

A course for your people, or a place for yourself?

Tell us who you need to prepare — a team, a cycle, yourself — and the person who wrote the material answers.

Write to us