Thice - Code Less. Control Everything.

Why Thice?

The best of all worlds, without the trade-offs.

Feature	Java / C#	Python / Node	Rust / C++	Thice
Verbosity	High (Boilerplate)	Low	Medium	Minimal
Performance	VM/JIT	Interpreted	Native	LLVM Zero-Cost
Learning Curve	Medium	Low	High	Low
Infrastructure	External SDKs	External SDKs	Manual	Native Directives
Security	Runtime	Runtime	Memory Safe	Compile-time Audit
Vendor Lock-in	SDK Coupled	SDK Coupled	SDK Coupled	Agnostic by Design

Where Thice Shines

Built for the challenges of modern software.

$

Fintechs & Trading

Native decimal type for precision. :snapshot for transaction forensics. Microsecond latency with LLVM.

→

Edge & IoT

Tiny binaries, no runtime. Run AI inference directly on devices with :ia directives.

↗

High-Scale Backend

Structured concurrency with :async and :race. 10-50x less resources than interpreted languages.

◉

Compliance & Audit

LGPD, GDPR, SOX, PCI-DSS ready. Automatic data flow tracking and capability manifests.

Security & Compliance

Built for regulated industries. LGPD, GDPR, SOX, PCI-DSS ready by design.

Traditional security is reactive. You audit code after it's written, hoping to catch vulnerabilities before production. Thice inverts this model. Security rules are enforced at compile-time, making entire categories of bugs and data leaks impossible to deploy. Your compliance team can validate policies in the build pipeline, not in manual reviews.

[ ] Data Loss Prevention

Mark any field as sensitive using metadata. The compiler tracks this data through your entire codebase. If it tries to reach logs, network, or stdout without explicit sanitization, the build fails. No more accidental PII leaks.

** Mark sensitive data with directive
:frame User {
    :sensitive
    str credit_card;
}

** Build fails: data leak
:out f"CC: {user.credit_card}";

** OK: sanitized
:out f"CC: {user.credit_card.mask()}";

{ } State Snapshots

Financial systems need audit trails. With :snapshot, you create immutable checkpoints mid-transaction. Compare before/after states, implement rollback logic, or generate forensic reports with native language support.

processPayment(decimal amount) {
    :snapshot Before { balance };
    
    balance -= amount;
    
    ** Forensic trail
    :log f"Delta: {Before.balance - balance}";
}

:: Capability Manifest

Every Thice binary can emit a "security X-Ray" listing all external resources it accesses: network endpoints, filesystem paths, FFI calls. Your security team can block any build that requests unexpected permissions.

$ tc audit payment-service.tc

{
  "network": ["api.stripe.com:443"],
  "filesystem": ["/etc/secrets"],
  "unsafe_ffi": false,
  "sensitive_data_handled": 3
}

# Policy as Code

Define organization-wide security policies in a single file. Block unsafe operations, restrict cloud providers, ban vulnerable libraries. Enforced automatically on every build across all teams.

** Enterprise policy.tc
:deny :unsafe;          ** No raw pointers
:deny :net.http;        ** HTTPS only
:deny_lib "log4j";      ** Known vuln
:require :audit_log;    ** All services

Code in Action

Expressive syntax that reads like intent.

Hello World

:space app {
    :frame Main {
        main() {
            :out "Hello, Thice!";
        }
    }
}

Minimal ceremony. Just code.

Frames & Methods

:frame +User {
    str name;
    int id;
    
    greet() {
        :out f"Hi, {.name}";
    }
}

Clean type definitions with methods.

Expressive Loops

** Exclusive range (0-9)
:loop [i:0..10] { :out i; }

** Inclusive range (0-10)
:loop [i:0=..=10] { :out i; }

** Nested loops (double comma)
:loop [i:0..3,, j:0..3] { :out f"{i},{j}"; }

Range operators that make sense.

Control Flow

:if x > 0 {
    :out "positive";
}:{             ** else
    :out "not positive";
}::{            ** always (finally)
    :out "cleanup";
}

Clean branching with always blocks.

Error Handling

:try {
    data = fetchData();
}:: NetworkError e {   ** handle
    :log f"Net error: {e}";
    :return null;
}::{                   ** always
    cleanup();
}

Built-in try/handle/always flow.

Enums & Fields

:frame Status {
    ** Enum block (first in frame)
    [OK, ERROR = 1, WARNING];
    
    +str message;       ** public field
    -int code;          ** private field
    @decimal TAX = 0.15; ** const
}

Enums and visibility are first-class.

Universal Interoperability

Integrate with any ecosystem. No rewrites required.

Thice doesn't exist in isolation. Your organization has decades of C libraries, proven Rust crates, and critical Go services. Thice compiles to LLVM IR, the same backend used by Clang, Swift, and Rust, enabling zero-overhead integration with existing code. Call C functions directly, link Rust crates, or expose Thice modules to other languages. One platform, every ecosystem.

LLVM Backend

Compile to the same IR as Clang, Swift, and Rust. Access decades of optimization work and target any platform LLVM supports.

C / C++ FFI

Call C and C++ libraries directly. No bindings generation needed. Use the :ffi directive to link existing code.

:ffi "sqlite3.h";
db = sqlite3_open("app.db");

Rust Integration

Link Rust crates via LLVM. Share memory-safe abstractions between Thice and Rust codebases.

Go Interop

Call Go packages using cgo-compatible interfaces. Leverage Go's networking and concurrency primitives.

Vendor Neutrality

Infrastructure directives abstract cloud providers. Write once, deploy anywhere: AWS, GCP, Azure, or on-premise. The code defines what, the config defines who provides.

:cloud.upload(file);      ** Provider agnostic
:db.query("SELECT *");    ** Any SQL database  
:queue.push(message);     ** RabbitMQ, Kafka, SQS...

Thice Passport

Verified developer identity for a trusted ecosystem.

The software supply chain is under attack. Typosquatting, abandoned packages, anonymous maintainers uploading malware. Enterprises face real risk from dependencies they can't verify. Thice Passport solves this by requiring every registry publisher to complete identity verification. When you import a package, you know a real, legally-accountable developer stands behind it.

$19 one-time

Know Your Developer (KYD)

The registry rejects anonymous submissions. Every published package includes a verified identity, making social engineering attacks and malicious takeovers far more difficult.

→ Identity verification via Stripe Identity (coming soon)
→ Code signing certificates for your libraries
→ Enterprise trust badges for organizations
→ Legal accountability for published packages
→ Priority support and early access

CTOs can trust that every dependency has a verified, accountable developer behind it.

THICE PASSPORT

ID: TC-2025-XXXXX

Developer Name

✓ Verified

Ready to build?

Join developers who demand performance, clarity, and control.

Get Started Join Discord

Code Less.Control Everything.