Write Objective-C.
Ship plain C.

An Objective-C transpiler for Zephyr RTOS. Classes, protocols, properties, blocks and ARC — lowered to C your team can read, on the compiler you already use.

No runtime, no objc_msgSend, no second compiler, no FFI bindings — and the whole Zephyr macro and devicetree API stays directly callable, because the file is still C.

Get started View on GitHub

−28% firmware vs C++
12 cycles per call
0 bytes of heap
0 bindings to maintain
v0.5.99 · pre-1.0

What it emits

One file, and the C it becomes

Scroll the Objective-C on the left — or hover any part of it. The generated C keeps pace on the right, highlighting the matching lines and saying what you gain. Every line of it is the transpiler's own output for this one file.

thermostat.m you write

/*
 * Demo source for objective-z.org. Everything under generated/ is
 * oz_transpile's own output for this file.
 */
#import <Foundation/Foundation.h>

#include <zephyr/kernel.h>
#include <zephyr/zbus/zbus.h>

@protocol Sensor
- (int)read;
@end

@interface Thermometer : OZObject <Sensor> {
        int _offset;
}
- (int)read;
@end

@implementation Thermometer

- (int)read
{
        return 21 + _offset;
}

@end

@interface Hygrometer : OZObject <Sensor> {
        int _humidity;
}
- (int)read;
@end

@implementation Hygrometer

- (int)read
{
        return _humidity;
}

@end

@interface Thermostat : OZObject {
        int _setpoint;
        BOOL _heating;
        Thermometer *_probe;
        OZArray *_bank;
        OZTimer *_poll;
}
@property (atomic) int setpoint;
@property (nonatomic, getter=isHeating) BOOL heating;

- (instancetype)initWithProbe:(Thermometer *)probe pollEvery:(uint32_t)periodMs;
- (int)worstReading;
- (int)spotCheck;
- (BOOL)shouldHeat;
@end

@implementation Thermostat

@synthesize setpoint = _setpoint;
@synthesize heating = _heating;

- (instancetype)initWithProbe:(Thermometer *)probe pollEvery:(uint32_t)periodMs
{
        _probe = probe;
        _bank = @[ probe, [[Hygrometer alloc] init] ];

        _poll = [[OZTimer alloc]
                initWithUserData:self
                expiry:^(struct k_timer *t) {
                        Thermostat *me = (__bridge Thermostat *)
                                k_timer_user_data_get(t);
                        [me setHeating:[me shouldHeat]];
                }
                stop:nil];
        [_poll startAfter:periodMs period:periodMs];
        return self;
}

- (int)worstReading
{
        int worst = 0;

        for (id sensor in _bank) {
                int value = [sensor read];

                if (value > worst) {
                        worst = value;
                }
        }

        return worst;
}

- (int)spotCheck
{
        Thermometer *spare = [[Thermometer alloc] init];
        int reading = [spare read];

        return reading;
}

- (BOOL)shouldHeat
{
        return [_probe read] < _setpoint;
}

@end

struct msg_setpoint {
        int celsius;
};

/* A Zephyr macro, used verbatim in an Objective-C file. No binding layer. */
ZBUS_CHAN_DEFINE(chan_setpoint, struct msg_setpoint, NULL, NULL,
                 ZBUS_OBSERVERS(lis_setpoint), ZBUS_MSG_INIT(0));

static Thermostat *unit;

/* A plain C callback that talks to the object. */
static void on_setpoint(const struct zbus_channel *chan)
{
        const struct msg_setpoint *msg = zbus_chan_const_msg(chan);

        [unit setSetpoint:msg->celsius];
}

ZBUS_LISTENER_DEFINE(lis_setpoint, on_setpoint);

int main(void)
{
        Thermometer *probe = [[Thermometer alloc] init];

        unit = [[Thermostat alloc] initWithProbe:probe pollEvery:1000];
        [unit setSetpoint:21];

        OZLog("worst=%d heating=%d", [unit worstReading], [unit isHeating]);
        return 0;
}

1. A protocol becomes a function-pointer type. Nothing is allocated and nothing is registered at startup — the abstraction costs you a typedef.

2. The class becomes a struct whose first member is its superclass, so an upcast is a pointer cast. The method becomes a function taking self explicitly, and a send to a known type costs 12 cycles — exactly what the C call costs.

3. With two classes conforming, the protocol needs a table. It is const, so it lands in .rodata — FLASH, not RAM. Polymorphism for zero bytes of RAM.

4. atomic wraps both accessors in a real Zephyr k_spinlock guard — 10 cycles to read, two fewer than the C++ equivalent, because it is the kernel's own primitive and not a library mutex. getter=isHeating names the function; the setter keeps its conventional name.

5. An array literal becomes a stack buffer of retained objects. The block is lifted out as a file-scope function and handed to the timer by name — which is why only non-capturing blocks are allowed, and why invoking one costs the same 12 cycles as a C++ lambda. __bridge is just a cast.

6. Fast enumeration becomes an explicit iterator loop. Because sensor is id, the read goes through the protocol table: one indexed load, 21 cycles, with no message lookup and no dispatch cache to miss.

7. Nothing in this method mentions memory — and yet a release appears. ARC works out that spare dies at the closing brace and writes the call, before the return, at compile time. No collector, no runtime bookkeeping, and zero heap: the pool above is a fixed slab in .bss, sized from the AST, with no allocator header per object.

8. A known receiver collapses to a direct call. Below it is a whole function that appears in no source file: the class declares no -dealloc, so ARC wrote one, releasing each strong ivar in turn before handing off to the superclass.

9. This is the part no other language gets for free. ZBUS_CHAN_DEFINE and ZBUS_LISTENER_DEFINE are C preprocessor macros that build linker-section structures; here they sit in a .m file and come out untouched. Zero bindings to write, and none to fix when Zephyr changes. A plain C callback talks to the object — only the message send is rewritten.

10. And it runs. Every message is an ordinary call, ARC releases the local probe on the way out, and the whole file goes through the same GCC as the rest of your firmware — no second compiler, and 28% smaller than the equivalent built as C++.

generated C thermostat_ozm.c

typedef int (*OZ_fn_read)(struct OZObject *);
struct Thermometer {
    struct OZObject base;
    int _offset;
};

int Thermometer_read(struct Thermometer *self)
{
    return 21 + self->_offset;
}
const OZ_fn_read OZ_PROTOCOL_RESOLVE_read[OZ_CLASS_COUNT] = {
    [OZ_CLASS_Hygrometer] = (OZ_fn_read)Hygrometer_read,
    [OZ_CLASS_Thermometer] = (OZ_fn_read)Thermometer_read,
};

int Hygrometer_read(struct Hygrometer *self)
{
    return self->_humidity;
}
struct Thermostat {
    struct OZObject base;
    int _setpoint;
    bool _heating;
    struct Thermometer * _probe;
    struct OZArray * _bank;
    struct OZTimer * _poll;
};

int Thermostat_setpoint(struct Thermostat *self)
{
    int val = {0};
    OZ_SPINLOCK(&self->base._oz_prop_lock) {
        val = self->_setpoint;
    }
    return val;
}

void Thermostat_setSetpoint_(struct Thermostat *self, int setpoint)
{
    OZ_SPINLOCK(&self->base._oz_prop_lock) {
        self->_setpoint = setpoint;
    }
}

BOOL Thermostat_isHeating(struct Thermostat *self)
{
    return self->_heating;
}
static void _oz_block_L0_C0(struct k_timer * t)
{
    struct Thermostat * me =
        (struct Thermostat *)k_timer_user_data_get(t);
    Thermostat_setHeating_(me, Thermostat_shouldHeat(me));
}

    struct OZObject *_oz_arr_0_buf[] = {
        (struct OZObject *)OZObject_retain(
            (struct OZObject *)(struct OZObject *)probe),
        (struct OZObject *)OZObject_retain(
            (struct OZObject *)(struct OZObject *)
            (struct Hygrometer *)OZObject_init(
                (struct OZObject *)Hygrometer_alloc()))};
    struct OZArray *_oz_recv1 =
        OZArray_initWithItems(_oz_arr_0_buf, 2);
    OZObject_release((struct OZObject *)self->_bank);
    self->_bank = _oz_recv1;
    struct OZTimer *_oz_recv2 =
        OZTimer_initWithUserData_expiry_stop_(
            OZTimer_alloc(), (struct OZObject *)self,
            _oz_block_L0_C0, (((void *)0)));
    OZObject_release((struct OZObject *)self->_poll);
    self->_poll = _oz_recv2;
    OZTimer_startAfter_period_(self->_poll,
                               periodMs, periodMs);
int Thermostat_worstReading(struct Thermostat *self)
{
    int worst = 0;
    {
        struct OZObject *_oz_iter0 = (struct OZObject *)
            OZ_PROTOCOL_SEND_iter((struct OZObject *)self->_bank);
        struct OZObject *_oz_recv1 = _oz_iter0;
        for (const  id sensor =
                 (const  id)OZ_PROTOCOL_SEND_next(_oz_recv1);
             sensor != ((void *)0);
             sensor = (const  id)OZ_PROTOCOL_SEND_next(_oz_recv1)) {
            struct OZObject *_oz_recv2 = (struct OZObject *)sensor;
            int value = OZ_PROTOCOL_SEND_read(_oz_recv2);
            if (value > worst) {
                worst = value;
            }
        }
    }
    return worst;
}



#define OZ_PROTOCOL_SEND_read(obj)                       \
    OZ_PROTOCOL_RESOLVE_read[                            \
        ((struct OZObject *)(obj))->_meta.class_id](     \
            (struct OZObject *)(obj))
OZ_SLAB_DEFINE(oz_slab_Thermometer, sizeof(struct Thermometer), 2, 4);

int Thermostat_spotCheck(struct Thermostat *self)
{
    struct Thermometer * spare = (struct Thermometer *)
        OZObject_init((struct OZObject *)Thermometer_alloc());
    int reading = Thermometer_read(spare);
    OZObject_release((struct OZObject *)spare);added by the transpiler
    return reading;
}
BOOL Thermostat_shouldHeat(struct Thermostat *self)
{
    return Thermometer_read(self->_probe) < self->_setpoint;
}

void Thermostat_dealloc(struct Thermostat *self)added by the transpiler
{
    OZObject_release((struct OZObject *)self->_probe);
    OZObject_release((struct OZObject *)self->_bank);
    OZObject_release((struct OZObject *)self->_poll);
    OZObject_dealloc((struct OZObject *)self);
}
struct msg_setpoint {
        int celsius;
}
;
/* A Zephyr macro, used verbatim in an Objective-C file. No binding layer. */
ZBUS_CHAN_DEFINE(chan_setpoint, struct msg_setpoint,
                 NULL, NULL,
                 ZBUS_OBSERVERS(lis_setpoint),
                 ZBUS_MSG_INIT(0));
static struct Thermostat * unit;
/* A plain C callback that talks to the object. */
static void on_setpoint(const struct zbus_channel * chan)
{
    const struct msg_setpoint * msg = zbus_chan_const_msg(chan);
    Thermostat_setSetpoint_(unit, msg->celsius);
}

ZBUS_LISTENER_DEFINE(lis_setpoint, on_setpoint);
int main(void)
{
    struct Thermometer * probe = (struct Thermometer *)
        OZObject_init((struct OZObject *)Thermometer_alloc());
    unit = Thermostat_initWithProbe_pollEvery_(
        Thermostat_alloc(), probe, 1000);
    Thermostat_setSetpoint_(unit, 21);
    OZLog("worst=%d heating=%d",
          Thermostat_worstReading(unit), Thermostat_isHeating(unit));
    OZObject_release((struct OZObject *)probe);added by the transpiler
    return 0;
}

How the pipeline fits together 3 passes, one Python step

Clang parses your .m into a JSON AST. oz_transpile collects classes and protocols, resolves the hierarchy and classifies every dispatch, then emits per-class .h/.c plus the dispatch tables. GCC takes it from there. Objective-C is never compiled — it is translated.

The rest of the supported language categories, blocks, literals, generics

Categories merged at AST collection time; @synchronized as a RAII spinlock; +initialize called before main() via SYS_INIT.
__block variables are promoted to file scope (blocks themselves are shown above).
Fast enumeration — for (id obj in collection); boxed and collection literals — @42, @[a, b], @{k: v}, and subscripting.
Lightweight generics for typed collections.
Foundation — OZObject, OZString, OZMutableString, OZArray, OZDictionary, OZQ31 fixed point, OZHeap, OZSpinLock, OZTimer, OZDefer, OZLog.
Removed on purpose — KVO, swizzling, dynamic class creation, associated objects, weak references, message forwarding. Each needs unbounded runtime allocation.

Full reference in the project README.

What it will not do read this before committing a project

Non-capturing blocks only — capturing a local is a transpile-time error.
No typedef, no @try/@catch/@throw, no __weak (it panics at runtime).
Single inheritance — an Objective-C constraint, not a transpiler one.
No dynamic dispatch for non-protocol methods; everything resolves statically.
OZQ31 converts to int8/16/32 and float — no int64 or double.

Complete list in docs/LIMITATIONS.md.

Results

Smaller firmware than C++, same dispatch cost

Same benchmark application built both ways on an nRF52833 DK (Cortex-M4F @ 64 MHz), DWT cycle counter, overhead-calibrated.

Build	C++	Objective-Z	Diff
Total firmware, `-O2`	60,761	43,645	−28%
Flash, `-O2`	50,900	35,040	−31%
RAM, `-Os`	15,738	7,524	−52%
Static / direct call	12	12	same
Virtual / vtable dispatch	14	21	+50%
Per-object allocation cost	24 B	16 B	−33%

Bytes for firmware and allocation rows, cycles for dispatch rows. C++ template and STL inlining is what inflates text; the RAM saving comes from slab pools in .bss replacing a sys_heap.

Full benchmark tables speed, memory, footprint at both -O2 and -Os

Speed

Cycle counts — lower is better. Both sides `-O2`.
Operation	C++	Objective-Z	Notes
Static / direct call	12	12	Both resolve at compile time
Virtual / vtable dispatch	14	21	OZ: `const` array; C++: vptr indirection
Slab alloc + init + release	105	215	C++ figure is placement-new from a slab
Atomic inc (retain)	7	22	Both inline atomics
retain + release pair	17	44
Property get (nonatomic)	12	12
Property get (atomic, `k_spinlock`)	12	10	Same Zephyr primitive on both sides
`@synchronized` (`k_spinlock`)	15	266	OZ: RAII `OZSpinLock` alloc + free
Block / lambda (non-capturing)	12	12	Both compile to function pointers
`std::function` (int capture)	16	—	No Objective-Z equivalent
Raw `int32_t[]` sum (10 elems)	81	99	Both raw C arrays, no boxing
String array loop + length (10)	263	483	Fair: both call a method per element
String iterator (virtual)	211	341	Fair: both virtual dispatch per step
`dynamic_cast` / `isKindOfClass`	12	—	OZ introspection is a C API

Memory per object

Bytes. C and C++ use a dedicated 8 KB `sys_heap`; Objective-Z uses per-class `k_mem_slab` pools.
Metric	C	C++	Objective-Z
Base object `sizeof`	8	8	8
Allocator overhead per object	4–8	4–8	0
`shared_ptr` control block	—	12	0
GrandChild, allocated	24	24	16
20 × GrandChild	480	480	320
String object	—	12	20

Firmware footprint

Bytes. Negative diff favors Objective-Z.
Benchmark	Metric	C++	Objective-Z	Diff
Speed (`-O2`)	text	50,588	34,272	−32%
	data	312	768	+146%
	bss	9,861	8,605	−13%
	total	60,761	43,645	−28%
	Flash	50,900	35,040	−31%
	RAM	10,173	9,373	−8%
Memory (`-Os`)	text	22,840	21,344	−7%
	data	180	180	0%
	bss	15,558	7,344	−53%
	total	38,578	28,868	−25%
	Flash	23,020	21,524	−6%
	RAM	15,738	7,524	−52%

Per-section results — allocation, dispatch, lifecycle, refcounting, collections — are in the README benchmark section.

Where C++ still wins the honest list

@synchronized costs 266 cycles against 15, because the RAII OZSpinLock is allocated and freed. Use k_spinlock directly on a hot path.
Reference counting is slower — 22 cycles to retain vs 7 for a raw atomic_fetch_add; 44 vs 17 for a pair.
Placement-new from a slab is 2× faster — 105 cycles vs 215, which covers init plus the ARC release.
Object-array iteration is ~1.8× slower — 483 cycles vs 263 over ten elements.
No counterpart for capturing std::function, dynamic_cast, or multiple inheritance.

Why not Rust, Zig, Nim, Swift, Ada, Lua or Go? eight evaluations

Each fails for its own reason — a separate compiler (Rust, Zig, Swift, Ada), broken macro compatibility (all of them, C++ and Nim included), an unfamiliar language model (Rust, Nim, Ada), a hobbled subset (Swift), an interpreter with heap allocation (Lua), a garbage collector (Go) — but they share a root cause: each asks the embedded C team to leave C.

Rust — separate compiler, two-ABI friction, FFI bindings that break on upstream updates, kernel work effectively off-limits.
C++ — K_THREAD_DEFINE and DEVICE_DT_DEFINE rely on C preprocessor behavior; g++ changes the language under the macros. And C++03 vs C++20/23 is effectively a different language.
Zig — the most sympathetic "better C", but a separate compiler and no OOP at all: no classes, no inheritance, no dispatch.
Nim — also transpiles to C, but is a wholly different language whose FFI cannot pass Zephyr's macros; GC'd reference types by default and Nim-idiomatic output.
Swift — separate ABI, experimental embedded subset that disables the features making Swift feel like Swift.
Ada / SPARK — deserves respect for formal verification, but has no official Zephyr support and an enormous adoption cost.
Lua — interpreted, so WCET analysis is out, and the VM heap-allocates tables and closures.
Go / TinyGo — the garbage collector is a one-line disqualifier.

Long-form reasoning for each is in the README.

Quick start

Four files and one CMake call

west.yml

- name: objective-z
  url: https://github.com/rodrigopex/objective-z/
  revision: main
  path: objective-z

CMakeLists.txt

objz_transpile_sources(app src/main.m)

prj.conf

CONFIG_OBJZ=y

build

west update
west build -p -b mps2/an385 .

Needs the Zephyr SDK and west, Clang 20+ for AST analysis, and Python 3. Twelve runnable samples ship in samples/ — from hello_world to zbus pub/sub and a request-response service. Targets ARM Cortex-M, Cortex-A and RISC-V 32/64.

Read the docs on GitHub