Homegrown kernel · Rust from scratch · Built for security
The sovereign OSfor cybersecurity.
Priente-OS is written from scratch in Rust, from the UEFI loader up through the kernel, and built for one job: running cybersecurity products. It is not a fork of another kernel: every layer is ours, and every line is auditable. Your products run on it without changing a single line.
Animated boot log: the signed loader is verified, the kernel starts, hardware protections and the read-only system image are enabled, products start inside their own isolation boundaries and the system is ready.
- 100%Rust: memory safety is part of the design
- 0external dependencies: no door for supply-chain risk
- 0lines to change: your products run as they are
- A/Bsigned, seamless updates with instant rollback
Architecture
Framekernel: unsafe code lives in one cage.
The Priente-OS kernel comes in two parts. A small trusted core that talks to the hardware is the only place unsafe code may exist. Everything else, including processes, filesystems, the network stack and drivers, is written in safe Rust, where the compiler rejects unsafe code outright. Less to audit, far less to attack.
Select a layer · live system call flow
Cybersecurity products
Priente products and partners’ security software run as they are, without recompiling or patching. Every product lives inside its own isolation boundary.
- No recompiling
- No patching
- Per-product isolation
- Go · Rust · C/C++
Priente system layer
Service management, time sync, logging and management tools, rewritten in Rust. The system updates as one signed A/B image, and management happens only through a signed API.
- Service management
- Central logging
- Time sync
- A/B updates
- Signed management API
System call ABI
The contract between products and the kernel, written from scratch by us. The system calls, signals and binary loading applications expect are implemented one to one; every call that is not allowed is rejected and logged.
- Binary loading
- Signals
- Threads
- Event loops
- Syscall allowlist
priente-kernel
Most of the kernel lives here, all of it safe Rust: process management, filesystems, the network stack, firewall, VPN and drivers. In this layer the compiler does not allow unsafe code.
- Process isolation
- Filesystems
- IPv4 / IPv6
- Firewall and NAT
- WireGuard
- virtio drivers
priente-core
The trusted computing base: interrupts, multi-core support, memory management, context switching and hardware access. Small, isolated and auditable line by line; every unsafe block carries a written justification.
- Memory management
- Multi-core
- Interrupts
- Hardware protection
- MMIO / DMA
prienteboot
Our own UEFI loader. The kernel is embedded inside it: one file, one signature chain. With Secure Boot and TPM measured boot, the system is verified from the very first instruction.
- UEFI
- Secure Boot
- TPM measured boot
- KASLR
Compatibility
Your products stay the same. The OS beneath them changes.
Priente-OS implements, in its own kernel, the system call interface applications already speak. Your product runs exactly as built; you simply move it onto far safer ground.
Runs as it is
Zero migration cost- No recompilingExisting binaries run exactly as they were built.
- No code changesYou do not change a single line of source code.
- Identical behaviorEvery product passes side-by-side tests against its current environment.
- Any language, any runtimeGo, Rust, C and C++; statically or dynamically linked.
- Tools includedThe system tools and scripts products call are built in.
- Networking and storage built inFirewall, NAT, VPN, VLAN and persistent disk.
Bring your product
- 01Bring itBring your product as it is, change nothing.
- 02We verifySide-by-side tests against your current environment.
- 03Ship itAs a signed image, with A/B updates, to the field.
Built into Priente-OS
- Memory-safe kernel
- Secure Boot
- TPM measured boot
- KASLR
- SMEP · SMAP · UMIP
- W^X
- Read-only root image
- A/B updates
- Instant rollback
- Syscall allowlist
- Audit log
- No kernel modules
- No shell
- No SSH
- Signed management API
- Zero external dependencies
- Multi-core
- IPv4 / IPv6
- Firewall
- NAT
- WireGuard VPN
- VLAN
- Network bridge
- Traffic shaping
- Persistent disk
- Homegrown source code
- KVM · VMware · Cloud
Security model
Not bolted on. Secure by construction.
Security is not a feature list; it is the architecture itself. From boot to runtime, every layer works by your rules, not the attacker’s.
Compiler-enforced kernel
Unsafe code exists only in a small, isolated core. Everywhere else in the kernel the compiler forbids it, and the boundary is checked automatically on every change.
Hardware-backed protection
SMEP, SMAP, UMIP, NX and W^X draw hard lines between kernel and user memory. KASLR makes an attacker’s job harder from the very start.
Zero external dependencies
Not a single third-party component in the kernel or loader. No open door for supply-chain attacks.
Per-product syscall allowlist
Each product can use only the system calls it needs. Every call that is not allowed is rejected and written to the audit log.
Verified boot
A single signed UEFI loader, Secure Boot and TPM measured boot. The system is provably intact from the very first instruction.
Immutable system, no shell
A read-only, signed root image with A/B updates and instant rollback. No kernel modules, no SSH and no shell; management happens only through a signed API.
Products
Cybersecurity only. Priente first.
Priente-OS is not a general-purpose operating system. Its only job is to run cybersecurity products as securely and efficiently as possible. Priente’s product family comes built in.
- Built into Priente-OSPRIENTE
NameDefence
Protection at the DNS layer, a secure web gateway and network visibility.
- Built into Priente-OSPRIENTE
AccessVerifier
Hotspot and network access control: captive portal, session management, URL filtering and firewall.
- Built into Priente-OSPRIENTE
Allarmia
Part of the Priente security family, running natively on Priente-OS.
- Built into Priente-OSPRIENTE
GuardPot
Part of the Priente security family, running natively on Priente-OS.
One platform, every security product.
- One signed imageEvery product in a single, verified system image.
- Per-product isolationEach product within its own system call boundaries.
- Central updatesSeamless renewal, with instant rollback if anything goes wrong.
Deploy
Up and running in minutes.
Priente-OS ships as a virtual machine. It installs without touching your existing infrastructure and keeps itself current with signed updates.
Runs on
- KVM / QEMU
- VMware
- Cloud
- 01
Get the image
One signed system image, with your products inside.
- 02
Boot it
On KVM, VMware or in the cloud; the same image everywhere.
- 03
Configure
Through the signed management API; no shell or SSH needed.
- 04
Forget it
A/B updates keep it current and roll back if needed.
Bug Bounty
Try to break our kernel.
A security claim is only as strong as the people trying to break it. We are opening Priente-OS to researchers: find a vulnerability, report it responsibly, and claim your reward and your place in the hall of fame.
Rewards are set by the severity of the finding.
Scope
- 01
Boot chain and TCB
Breaking the Secure Boot chain, memory-safety violations in the core, or code execution in kernel context.
- 02
Process isolation
One product reaching another’s memory, privilege escalation, escaping the allowlist.
- 03
System call surface
Kernel crashes, persistent denial of service or memory leaks through system calls.
- 04
Network stack
Bypassing firewall rules, packet handling bugs, remotely triggered vulnerabilities.
Severity
- CriticalCode execution in the core, cross-product memory reads or writes, remote takeover
- HighPrivilege escalation, allowlist bypass, breaking the boot chain
- MediumKernel information leaks, persistent denial of service
- LowCrashes and malformed-input handling with limited security impact
How it works
- 01Get the imageRequest the test image that runs in a virtual machine.
- 02Find the bugTest the layers in scope.
- 03Report itSend us reproducible steps, privately.
- 04We fix itWe verify, fix and keep you posted.
- 05Reward and creditYour reward and your place in the hall of fame.
Hall of fame
The first name could be yours.
Ecosystem
A homegrown kernel is not one team’s job.
We invite researchers, academia, cybersecurity vendors, engineers and institutions into the Priente-OS ecosystem.
Security researchers
Test the kernel, the system call surface and the boot chain. Every vulnerability you find makes the system stronger.
Bug bountyUniversities and academia
Operating systems and systems security research, thesis topics and internship partnerships.
Propose a collaborationCybersecurity vendors
Run your product on Priente-OS without changing it. Let’s do the move and the verification together.
Compatibility callEnterprises and public sector
A homegrown, auditable platform for critical infrastructure. Let’s talk about deployment and a demo.
Request a demoEngineers
Want to grow a kernel written from scratch in Rust? Join the team.
Careers
A future secure from the kernel up, together.
Try Priente-OS, test it, build on it.