Define & generate
Describe types and interfaces in CIDL, Canopy’s canonical, language-neutral IDL. No C++ syntax is required to author the contract. Generate matching bindings, serialisation and schemas through the build.
Canopy development environment
From application development to confidential computing.
Build the application. Choose where it runs. Verify what you trust.
The difficult transition
A protected application needs more than a different place to run.
Moving into confidential computing changes how an application uses host services, crosses trust boundaries, handles keys and establishes which software may receive sensitive data.
Canopy brings contract generation, integration tools, a distributed runtime and confidential-computing components into one development environment built around language-independent contracts. Teams can preserve their application-facing interfaces while changing where components run and how they establish trust.
-
01Define
Describe the application contract.
-
02Build
Develop and test locally.
-
03Integrate
Connect services and tools.
-
04Protect
Place selected work in an enclave.
-
05Verify
Check evidence against policy.
The contract connects the stages. Composition, supported builds, security policy and operational testing still need engineering.
One development workflow
From the contract to the protected call.
Integrate & inspect
Connect browser clients, service APIs and tools using supported REST/OpenAPI, WebSocket/AsyncAPI, Proto3, JSON Schema and MCP surfaces.
Run & observe
Compose components across local, process and network boundaries. Follow calls, references and route changes through telemetry.
Protect & verify
Use supported Intel SGX execution and attestation components to check workload evidence and establish protected sessions.
C++ is the first implementation language. Canopy’s contracts are language-independent, with supported generated JavaScript clients today and further language implementations planned.
What the environment includes →Built with Canopy · Cerberus
A working command-and-control demonstrator in two and a half weeks.
Reports become a shared picture, with authorised tasking, published interfaces and external integration. The project also records independent hardware appraisal followed by a protected application call.
Team-reported development period, using existing Canopy capabilities and Cerberus-derived concepts. Demonstration scenarios use synthetic data.
What this enables
Collaborate without opening everything up.
Zero-trust applications
Combine workload evidence, protected sessions and application permissions. Access depends on the configured checks, not simply on being connected to the network.
Build around explicit trust decisions →A shared answer from private inputs
Build a confidential computation where participants contribute secrets to agreed code and receive an approved result without seeing each other’s raw inputs.
Explore confidential joint processing →Understanding trust
Four questions. Four distinct checks.
01 · Can we connect?
Network controls determine reachability. A connection alone does not establish who or what is at the other end.
02 · Which workload is it?
A workload identity binds a name to a key. Its assurance depends on the issuer and the checks behind that identity.
03 · What software is running?
Hardware evidence can identify a defined software boundary. A relying party checks it against an acceptance policy and binds it to the session.
04 · Is the information accurate?
Approved software can still receive inaccurate inputs. Provenance and independent sources support assessment; attestation does not establish the truth of an observation.
Explore the runtime
Watch a route break and repair.
The Y-topology telemetry capture visualises a Canopy test involving transport loss and route repair. Follow its recorded events or leave the animation looping on a display.
A recorded engineering test, separate from the Cerberus application demonstration.