The LogLine Papers

A Complete Architecture for Accountable Computation

"We will not execute what we cannot explain, and we will not explain what we cannot replay."

Ethics is Efficient

For fifty years, computing has operated on a broken premise: execute → record → hope. Actions happen. Logs are written. We hope they're accurate, complete, and unmodified.

This worked when computers were tools. It fails when computers are agents—making decisions, moving money, taking actions on our behalf.

LogLine inverts the architecture: record → consent → execute → receipt.

Nothing happens without a prior record of intent. Nothing executes without policy evaluation. Nothing completes without a cryptographic receipt.

2.3M
Evaluations/sec (Rust)
250M
Evaluations/sec (FPGA)
81%
Cost Reduction
50KB
Policy = 200M Transistors
View on GitHub Read the Papers

The Papers

A complete protocol suite for verifiable accountability in autonomous systems.

Prologue

00
Ethics is Efficient
One-page thesis and system invariants. The foundation of LogLine's architectural philosophy.

Foundations

PAPER 0
From Silicon to User
Economic rationale: accountability reduces total cost through structural constraints.

Protocol Specifications

PAPER I
The LogLine Protocol
The 9-field tuple. Ghost records. Threat model. The core mechanism for accountability.
PAPER II
JSON✯Atomic
Deterministic canonicalization. Same meaning = same bytes. Cryptographic stability.
PAPER III
LLLV
Ledger and Proof Vectors. Proof-carrying retrieval. Evidence capsules.
PAPER IV
TDLN
Deterministic Translation of Natural Language. Policy compilation. Consent protocol.
PAPER V
SIRP
Secure Intent Routing Protocol. Network transport. Capsules. Cryptographic receipts.
SYNTHESIS
Hardware as Text and Power
Substrate theory: signed text becomes structural power at the silicon level.
PAPER VI
Chip as Code
Computational realization. Hardware as backend. Policy execution in silicon.
View All Papers on GitHub →

Install

Get started with the LogLine reference implementation in minutes.

Clone the Repository

git clone https://github.com/LogLine-Foundation/Ethics-is-Efficient.git
cd Ethics-is-Efficient

Build the Project

cargo build --release

Run Tests

cargo test

Start the Resolver

cargo run --bin logline-resolver

Quick Verification

# Verify paper hashes
for f in docs/papers/LogLine_Papers_v1.0.1/*.md; do
    echo "$(b3sum "$f" | cut -d' ' -f1)  $f"
done

Verify

All claims in the LogLine Papers are verifiable through code and benchmarks.

Paper Verification

Every paper includes BLAKE3 hashes. Verify the canonical versions:

# Compute hashes for all papers
cd docs/papers/LogLine_Papers_v1.0.1
for f in *.md; do b3sum "$f"; done

# Compare against canonical manifest
cat manifests/canon_v1.0.1.json

Conformance Tests

Run the complete conformance test suite:

cargo test --all-features
./smoke-test.sh

Benchmark Reproduction

Reproduce the performance claims:

cargo bench

The 2.3M evaluations/sec (Rust) and 250M evaluations/sec (FPGA) metrics are reproducible in the reference implementation and hardware designs.

About

Partnership

The LogLine Papers and reference implementation represent a unique collaboration between human intuition and machine precision. This work demonstrates that ethics and efficiency are not opposing forces—they are complementary aspects of good engineering.

Citation

@techreport{logline2026,
  title       = {LogLine SecurityOS: A Protocol Suite for Verifiable Accountability},
  author      = {Voulez, Dan},
  year        = {2026},
  month       = {February},
  institution = {The LogLine Foundation},
  version     = {1.0.1}
}

Contact

License