effcc Compiler
The effcc Compiler is a production-grade toolchain delivering deterministic, energy efficient parallel execution. By extracting dataflow from high-level languages, it optimally maps application graphs to the Fabric architecture, unlocking accelerator-class efficiency.
%20(1).avif)
.avif)
Bring your own code
Using LLVM and MLIR infrastructure, the effcc Compiler provides a familiar frontend that automatically parallelizes standard C/C++ and TFLite code without user annotations. Simply drop in your code and compile.
Lightning-fast compilation
Unlike traditional FPGA synthesis tools, our research-backed place-and-route algorithms can compile code in minutes, allowing developers to refine, test, and deploy new functionality fast.
Harness the power of the Fabric with no overhauls
The effcc Compiler resolves scheduling and mapping decisions at compile time, eliminating runtime overhead and jitter for deterministic execution. It supports standard debugging with GDB-compatible tools and provides expert-level control through compiler-provided intrinsics and manual annotations.
Optimized for efficiency
Our proprietary Modular Optimization Framework (MOF) uses performance and energy modeling to choose the best parallelization strategies for your specific workload. The framework minimizes energy-intensive data movement by keeping values close to compute, while our NUPEA-aware mapping places critical instructions near memory for an average 28% speedup.
Expanding language and library support
We are continually expanding the effcc Compiler's support for popular languages and frameworks, offering developers more options and flexibility. Our growing software ecosystem includes a developer-friendly SDK, hand-optimized libraries for DSP and image processing, and visual debugging tools.
.svg)
Seamless integration with popular tools
The effcc Compiler is a drop-in replacement for GCC/Clang compilers, integrating seamlessly with existing developer tools.
.svg)
Transforming development on the Fabric architecture
Infrastructure observability and industrial automation
A remote sensing device should not spend its battery streaming raw data to a server to learn nothing happened. The Electron E1 general-purpose processor analyzes multiple sensor inputs on the device itself and transmits only conclusions: years of monitoring on one battery. That changes where you can put a sensor. Pipelines, substations, pumps in places a maintenance truck rarely reaches. Failures surface before they become outages, from a network you deploy once and rely on.
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Block quote
Ordered list
- Item 1
- Item 2
- Item 3
Unordered list
- Item A
- Item B
- Item C
Bold text
Emphasis
Superscript
Subscript
.svg)
Physical AI autonomy
On a drone, every watt spent on compute is a watt not keeping it in the air. The Electron E1 runs the whole autonomy pipeline, VIO, sensor fusion, and TinyMPC control, on one part in standard C and C++. No stack of specialized boards, no proprietary toolchain to learn, just code your team already writes. Stop choosing between a smarter drone and a longer mission, and spend the watts you get back on the payload that earns the flight.
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Block quote
Ordered list
- Item 1
- Item 2
- Item 3
Unordered list
- Item A
- Item B
- Item C
Bold text
Emphasis
Superscript
Subscript
.svg)
Space and defense operations
In orbit, every watt of compute is solar panel and radiator the spacecraft must carry. Power-hungry FPGAs and GPUs spend watts fast and take specialists to program. The Electron E1 processes more data on board for longer and transmits only mission-critical findings, in standard C and C++. The downlink carries answers instead of raw telemetry, and the engineers you already have program the payload. Design the mission, not new hardware.
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Block quote
Ordered list
- Item 1
- Item 2
- Item 3
Unordered list
- Item A
- Item B
- Item C
Bold text
Emphasis
Superscript
Subscript
Wearable technology
A wearable that needs a midday charge does not get worn, and a device nobody wears helps nobody. The Electron E1 runs always-on audio and sensing in milliwatts, so a badge or headset listens, guides, and logs the whole shift on one charge. Workers stop managing the device and it becomes part of the job. Hands stay free. Features stay on.
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Block quote
Ordered list
- Item 1
- Item 2
- Item 3
Unordered list
- Item A
- Item B
- Item C
Bold text
Emphasis
Superscript
Subscript
What happens the first time you point the effcc Compiler at your project.
What languages does the effcc Compiler support today?
C and C++ are fully supported. LiteRT and ONNX models are supported through an import step. We are expanding language and framework support.
Do my existing libraries and standard headers work?
Standard C library headers are supported, and language support otherwise follows Clang,including the `-std=` flag, so the dialect you build with today is the dialect you keep. Third-party code you build from source comes across the way your own code does, because thefrontend it compiles against is the one your project already targets.
Is it really a drop-in replacement? What changes in my build?
Yes. The effcc Compiler is built on LLVM and MLIR and presents a familiar frontend: the same option spellings as Clang for optimization levels, include and library paths, macros, linker scripts, dependency files and diagnostics. In most projects you change the compiler variable in your build and add a target flag.
Do I have to annotate my code to get parallelism?
No. The Modular Optimization Framework, our proprietary optimization layer, uses performance and energy modeling to choose the parallelization strategy for your specific workload, without annotations. You do mark which functions run on the Fabric with a single function attribute. If you want to steer the result, intrinsics and manual annotations are there for expert control.
How long does a compile take?
Minutes, not the hours a hardware synthesis flow takes. That is a deliberate design goal: our place-and-route algorithms are built so you can refine, test and deploy in a normal development loop rather than an overnight one.
What does the effcc Compiler do that GCC or Clang cannot?
It lays your program out in space, not just in time. The Modular Optimization Framework models both performance and energy to pick a parallelization strategy for your workload, then places and routes the result onto the Fabric. Scheduling and mapping are resolved at compile time, so execution is deterministic and jitter-free with no runtime scheduler to account for. Everything around that, the option spellings, the diagnostics, the tools in the box, is meant to feel like the compiler you already use.
Do I have to restructure my application to get a working build?
No. You point the effcc Compiler at the application you already have and the whole thing builds and runs. The compiler decides which functions become dataflow graphs on the Fabric, and the code it does not map runs on the same part as ordinary compiled code. Nothing is dropped from the build and nothing has to be rewritten before you can measure something real.
Can I hand-tune the result?
Yes. Intrinsics and manual annotations give expert control over how a graph is mapped, and standard Clang loop pragmas are honored, including sub-word vectorization for types narrower than 32 bits.
How do I know where my energy is going?
The Energy Profiler on Efficient Labs reports the energy of named regions of your code, so you can attribute joules to functions the way you would attribute time in a conventional profiler. It is free, runs in a browser and needs no login.
Does my team need dataflow or hardware expertise?
No. The point of compiler and hardware co-design is that the dataflow graph is the compiler's problem, not yours. Your team writes the C and C++ it already writes, uses the tools it already uses, and does not need the hardware description languages and synthesis skills an FPGA flow demands.
How do I get the compiler?
Toolchain downloads and developer documentation are available on our website. Sign up for access to either.
