Private Compute.
Verifiable Integrity.
Run sensitive workloads on infrastructure you own — with privacy guarantees, data integrity, and no vendor platform you have to trust.
Emulation so good you won't believe it's not Linux.
Trusting environments
is no longer sufficient.
Most infrastructure is built on delegated trust — cloud providers, hypervisors, vendors. For sensitive computation, that tradeoff doesn't hold.
5BSD provides the execution substrate: isolated, auditable, tamper-evident, and under your operational control.
Processes, jails, containers, and sockets interact only through explicitly granted capability descriptors. Unauthorized access paths are structurally absent.
No process holds capabilities it was not explicitly granted. Policy is defined once and enforced at the kernel — not approximated through configuration.
Security-relevant events are interceptable and authorizable before completion. Policy lives in userspace where it can be inspected, versioned, and audited.
Encryption keys are kernel-resident and never surfaced to userland. What happened can be proven without exposing what was processed.
Where unverifiable state
is not an option.
Environments where the cost of data exposure, tampered execution, or unauditable state is too high to delegate to someone else's platform.
Run inference and training on sensitive data without exposing inputs, weights, or intermediate state to the execution environment operator.
Process healthcare, financial, or legal data with audit trails that satisfy compliance requirements — without relying on vendor attestation.
Compute over sensitive datasets. Results are verifiable; inputs remain protected.
Sign and verify build artifacts, execution environments, and deployment pipelines from source to production.
Automated workflows over privileged systems with capability-bounded execution and signed outputs.
Systems where availability, integrity, and auditability are non-negotiable — on hardware you control, under policy you define.
Tamper-evident by design.
Traceable from execution to output.
Integrity and provenance are not add-ons. They are structural properties of how 5BSD executes workloads.
Capability boundaries enforce what can touch what. Keyvault keeps cryptographic material in the kernel. Signed artifacts and audit trails mean integrity can be verified after the fact — not just asserted at deployment.
- —Kernel-resident key management via Keyvault
- —Capability-bounded process and container isolation
- —Signed artifacts with verifiable provenance
- —Audit trails for every security-relevant event
Where did this data come from, how did it move, who touched it, what produced this result. 5BSD makes those questions answerable — without requiring trust in a third-party audit service.
- —Structured telemetry with OTLP output
- —Hardware-assisted execution tracing (Intel PT)
- —171 DTrace profiles via bsdinstruments
- —CPU power, temperature, and frequency telemetry
Built from first principles.
Each component addresses a specific failure mode in conventional infrastructure. Security properties are structural, not configured. Source is available for inspection at every layer.
Control exactly what your system can do — and lock everything else out.
The Capability Runtime is a kernel-level protection layer made up of discrete, auditable modules. cap_protect and SecurityCoalitions ensure processes, jails, files, sockets, and containers can only interact through explicitly granted capabilities — there is no other path. Keyvault keeps encryption keys in the kernel, never surfaced to userland. CapabilityAccessControlList adds fine-grained per-capability access lists on top.
Define your security policy in userspace. Enforce it at every layer.
Security policy shouldn't live only in the kernel. OpenEndpointSecurity surfaces a structured API to userspace for intercepting and authorizing events — process execution, file access, network activity — before they complete. mac_abac brings Attribute-Based Access Control into the MAC framework so policy can be defined and audited in userspace. pf closes the loop at the network boundary with stateful packet filtering.
First-class tools for building on and observing 5BSD — for the long term.
FreeBSDKit is a Swift framework for building native tools and applications on 5BSD. ObservableBSD gives you full visibility into what the system is doing: bsdinstruments ships 171 DTrace profiles with OTLP output for Grafana, Prometheus, and Loki; bsdtrace uses Intel Processor Trace for hardware-assisted execution tracing; hwtlm surfaces CPU power, temperatures, and frequencies. BSDGhidra (Apache 2.0) extends Ghidra for BSD systems.
All permissively licensed. All open source.
Endpoint security monitoring and authorization for userland
Swift framework for building tools on 5BSD-derived systems
Kernel-resident encryption keys & capabilities
Attribute-Based Access Controls for the MAC framework
Descriptor capability for process/jail/file/container grouping
Observation and telemetry tools for 5BSD
Ghidra SRE framework for BSD systems — Apache 2.0
Capability model extended with access control lists
The 5BSD kernel source tree
Ready to run workloads
you can verify?
Read the documentation to understand the architecture, then explore the source. Everything is permissively licensed — BSD-2-Clause and Apache 2.0.
BSD-2-Clause and Apache 2.0 throughout. No licensing surprises when you ship products built on 5BSD.
Run Linux binaries without rewriting your stack. BSD foundations, Linux investment preserved.
We welcome contributors in OS engineering, security, virtualization, observability, and systems programming.