SwypikOS is an operating system — not an app you install on top of someone else’s. It owns machine authority: the kernel, capabilities, leases, recovery, devices, drivers and the desktop itself, with Ilaria built in as a cognitive provider, never an authority source. Our first-party kernel seed boots via UEFI in QEMU (emulation only); the desktop, agent and search are built and tested natively.
One machine. Your rules.
Six native tabs. Every action visible, every effect approved.
Cu ce lucrăm astăzi?
Salut, Ilaria! Ce putem face azi pe desktop?
EN · Hi Ilaria! What can we do on the desktop today?Replay for illustration. In the OS, answers come only from your configured Ilaria service — no service, no answer; errors are shown, never simulated.
Fix the failing duration test in parser.go
/resumeworkspace.read src/parser.goapproved · sha256 9f2c41…e7a1 recordedsearch.query “ParseDuration”approved · 3 local hitsworkspace.edit src/parser.goawaiting approval · edit bound to hash 9f2c41…e7a1 ✓ matches- fields := strings.Fields(s) + fields := strings.Fields(fold(s))
process.run go test ./parserpending · runs under lifecycle controlTry — a miniature of the engine’s Romanian/Hungarian folding, running in your browser.
# Proiect demo Workspace local pentru SwypikOS. - Agent: fiecare pas cere aprobare (F8 / F9) - Căutare: index propriu, BM25F - Ilaria: endpoint configurat explicit Nimic nu rulează fără acordul tău.
Consent off · no work is running.
Not crypto. No mining. No rewards. The Compute Fabric is in design — today the tab detects GPUs and records your consent; no work runs yet.
/ilaria https://…Switch the Ilaria endpoint explicitly/testCheck the endpoint — missing services fail loudly/workspace DIRSave the workspace for the next restartThe workspace is a working directory, not a security sandbox. Approved commands run with your permissions under process-lifecycle control — not a sandbox, stated plainly.
Try “open search”, “agent” or “compute” — this replica runs entirely in your browser.
Interactive replica of the SwypikOS desktop, rebuilt for the web. Click a tab, approve a step with F8, or search with and without diacritics. Content is illustrative.
What runs today, what we are proving and what we are designing — kept apart on purpose, and labelled on every surface.
A proprietary, freestanding kernel seed. It boots from UEFI and is validated in QEMU emulation; the final base architecture is still an open decision.
Its own UI engine and native rendering — no browser engine inside — with Ilaria’s approval-gated agent, its own search engine and files. Built and tested natively while the kernel matures.
A hardware-isolated reference environment running framebuffer UI, capability security, and verified sandboxing.
From the kernel to the pixels, SwypikOS is code we own: a first-party kernel, our own UI engine and native rendering. No Node, no HTTP UI server, no browser hiding inside the desktop — nothing between the machine and the code we wrote.
Ilaria plans one step at a time. F8 approves, F9 denies — and a prompt must be visible for 500 ms first. Edits need the file hash from a prior read, so stale content is never overwritten. Runs are checkpointed and survive restarts.
High-performance ranking, full diacritic normalization, prefix matching and contextual snippets. Sites are crawled only after explicit confirmation, honouring robots.txt and blocking private addresses. Zero dependence on third-party search APIs.
Chat talks to the Ilaria service you configure. No service, no answer: errors are shown, never simulated. The desktop never loads weights or starts servers behind your back.
The Compute tab detects NVIDIA GPUs and records your consent for future Ilaria training contribution. Off by default, and it says plainly that no work is running yet.
In current desktop previews, approved actions run under process-lifecycle control with user consent. Hardware capability isolation is the job of the SwypikOS kernel seed, which today runs in QEMU emulation only.
Not a Linux fork. A proprietary, freestanding kernel seed, validated in QEMU, that takes the machine from UEFI firmware into its own isolated execution domains — and treats every device as something a driver must be granted, never assumed.
Direct UEFI initialization taking complete control of system memory and execution contexts.
Hardware-enforced non-executable memory, isolated address spaces, and transactional mapping rollback.
User-mode initialization and driver execution at unprivileged levels with zero implicit device permissions.
Opaque, generation-protected security handles bound to explicit domains and lease fences.
Every MMIO, IRQ, DMA, and bus configuration access is strictly validated on each request.
DMA remapping that limits peripheral access to kernel and user memory (validated in QEMU).
Hardware timer scheduling designed for predictable latency and responsiveness (validated in QEMU).
Isolated failure domains designed to keep driver or task crashes away from the core operating system (validated in QEMU).
Cryptographically verified hardware topology safeguarding against hardware spoofing and probing.
Every request is revalidated by the device broker — domain, lease fence, handle generation, rights and object type — before any backend runs. Revoked handles fail forever.
Isolated address space · non-executable memory · zero ambient authority
0x0007·0042gen 7Revalidates every call before any backend runs
Generation counters never wrap back to a stale handle — an exhausted slot is retired.
The Control Kernel and Resource Governor enforce formal security invariants — governing machine authority, capability grants, and cross-boundary protocol integrity.
executor identity is authenticated and security-bound
Every effect executor proves who it is against a live Control Kernel lease. A stale fence or a forged identity cannot act.
side effects require explicit capabilities
There is no ambient authority. A plan names what it needs; SwypikOS mints exact, scoped grants — or refuses.
uncertain effects are never blindly replayed
If an outcome was never recorded, recovery escalates to an operator instead of guessing and running it twice.
Cryptographic identity verification against active kernel lease before effect dispatch.
All IO, memory, and hardware access require explicit, revocable, scoped capabilities.
State transitions verify postconditions and abort on any divergence or unexpected fault.
Subsystem or driver panic is contained in user-mode domains without affecting kernel core.
foreground responsiveness has priority over background work
disabled compute performs no synthetic work
background worker count is bounded
“Model confidence is never an authorization signal.”
Driver synthesis security contract
Every transition is journaled. A partially persisted transition is never assumed to have succeeded.
M1 verifies the portable contracts and a simulated unknown-device lifecycle. Real hardware rollout additionally requires controlled physical probes, signing and attestation policy, qualified hardware matrices and recovery testing.
People who install SwypikOS will be able to contribute idle GPU, CPU or NPU capacity to Ilaria training — a strategic compute plane, not a crypto, mining or reward feature.
The long-term direction: a first-party OS whose installer contains Ilaria — probing the hardware, then synthesizing, verifying, canarying and remembering support under explicit capability boundaries.
Ilaria may write code. It never gets unrestricted kernel authority.
“Universal” means one architecture, contract set and toolchain across devices — not a claim that every locked or proprietary device can be installed on without vendor permission or technical access.
Ambition is only credible next to an honest boundary. These limits come straight from our own engineering records.