Skip to main content
The Fern C API provides a C-compatible interface for using Fern in C projects and WebAssembly applications. This API is designed for simplicity and ease of integration with C codebases and web environments.

Core Types

Point

typedef struct Point {
    int x;
    int y;
} Point;
Represents a 2D point with integer coordinates.
Point Point_create(int x, int y);

FernCanvas

typedef struct FernCanvas {
    uint32_t* pixels;
    size_t height;
    size_t width;
} FernCanvas;
Represents the canvas pixel buffer.

InputState

typedef struct InputState {
    int mouse_x;
    int mouse_y;
    int mouse_down;
    int mouse_clicked;
} InputState;
Contains current mouse input state.

ButtonConfig

typedef struct ButtonConfig {
    int x;
    int y;
    int width;
    int height;
    uint32_t normal_color;
    uint32_t hover_color;
    uint32_t press_color;
    const char* label;
    int text_scale;
    uint32_t text_color;
    ButtonCallback on_click;
} ButtonConfig;
Configuration for button widgets.

GradientStop

typedef struct GradientStop {
    uint32_t color;
    float position;  // 0-1
} GradientStop;
Defines a color stop in a gradient.

LinearGradient

typedef struct LinearGradient {
    GradientStop* stops;
    int stop_count;
    int direction;  // 0 = horizontal, 1 = vertical
} LinearGradient;
Defines a linear gradient.

Color Constants

#define Colors_green  0xFF00FF00
#define Colors_blue   0xFF0000FF
#define Colors_red    0xFFFF0000
#define Colors_gray   0xFF202020
#define Colors_black  0xFF000000
#define Colors_white  0xFFFFFFFF

Gradient Constants

#define GRADIENT_HORIZONTAL 0
#define GRADIENT_VERTICAL   1

Initialization

fern_init_wasm()

void fern_init_wasm(uint32_t* pixel_buffer, size_t height, size_t width)
Initializes the Fern framework for WebAssembly.
pixel_buffer
uint32_t*
required
Pointer to the pixel buffer array
height
size_t
required
Canvas height in pixels
width
size_t
required
Canvas width in pixels

runApp()

void runApp(FernCanvas canvas)
Initializes and runs the Fern application.
canvas
FernCanvas
required
Canvas structure containing pixel buffer and dimensions

Drawing Functions

ffill()

void ffill(uint32_t* pixels, size_t height, size_t width, uint32_t color)
Fills the entire canvas with a solid color.
pixels
uint32_t*
required
Pixel buffer array
height
size_t
required
Canvas height
width
size_t
required
Canvas width
color
uint32_t
required
Fill color (0xAABBGGRR format)

frect()

void frect(uint32_t* pixels, size_t height, size_t width, uint32_t color, 
          size_t x, size_t y, size_t w, size_t h)
Draws a filled rectangle.
pixels
uint32_t*
required
Pixel buffer array
height
size_t
required
Canvas height
width
size_t
required
Canvas width
color
uint32_t
required
Rectangle color
x
size_t
required
Rectangle x position
y
size_t
required
Rectangle y position
w
size_t
required
Rectangle width
h
size_t
required
Rectangle height

fcircle()

void fcircle(uint32_t* pixels, size_t height, size_t width, uint32_t color, 
            size_t cx, size_t cy, size_t r)
Draws a filled circle.
pixels
uint32_t*
required
Pixel buffer array
height
size_t
required
Canvas height
width
size_t
required
Canvas width
color
uint32_t
required
Circle color
cx
size_t
required
Circle center x
cy
size_t
required
Circle center y
r
size_t
required
Circle radius

fline()

void fline(uint32_t* pixels, size_t height, size_t width, uint32_t color, 
          int x1, int y1, int x2, int y2, int thickness)
Draws a line between two points using Bresenham’s algorithm.
pixels
uint32_t*
required
Pixel buffer array
height
size_t
required
Canvas height
width
size_t
required
Canvas width
color
uint32_t
required
Line color
x1
int
required
Start point x
y1
int
required
Start point y
x2
int
required
End point x
y2
int
required
End point y
thickness
int
required
Line thickness in pixels

Text Rendering

fchar()

void fchar(uint32_t* pixels, int width, int height, char c, int x, int y, int scale, uint32_t color)
Renders a single character.
pixels
uint32_t*
required
Pixel buffer array
width
int
required
Canvas width
height
int
required
Canvas height
c
char
required
Character to render (A-Z, 0-9)
x
int
required
X position
y
int
required
Y position
scale
int
required
Character scale factor
color
uint32_t
required
Text color

ftext()

void ftext(uint32_t* pixels, int width, int height, const char* text, int x, int y, int scale, uint32_t color)
Renders a text string.
pixels
uint32_t*
required
Pixel buffer array
width
int
required
Canvas width
height
int
required
Canvas height
text
const char*
required
Text string to render
x
int
required
X position
y
int
required
Y position
scale
int
required
Text scale factor
color
uint32_t
required
Text color

Widget Functions

Container()

void Container(uint32_t color, int x, int y, int width, int height)
Draws a rectangular container.

CenteredContainer()

void CenteredContainer(int width, int height, uint32_t color)
Draws a centered rectangular container.

CircleWidget()

void CircleWidget(int radius, Point position, uint32_t color)
Draws a circle widget.

LineWidget()

void LineWidget(Point start, Point end, int thickness, uint32_t color)
Draws a line widget.

TextWidget()

void TextWidget(Point start, const char* text, int scale, uint32_t color)
Draws a text widget.

ButtonWidget()

void ButtonWidget(ButtonConfig config)
Draws an interactive button widget.

LinearGradientContainer()

void LinearGradientContainer(int x, int y, int width, int height, LinearGradient gradient)
Draws a container with a linear gradient.

Color Functions

fblend_color()

uint32_t fblend_color(uint32_t color1, uint32_t color2, float t)
Blends two colors together.
color1
uint32_t
required
First color
color2
uint32_t
required
Second color
t
float
required
Blend factor (0.0 to 1.0)
return
uint32_t
Blended color

gradient_color_at()

uint32_t gradient_color_at(LinearGradient grad, float position)
Calculates the color at a position in a gradient.
grad
LinearGradient
required
Gradient definition
position
float
required
Position in gradient (0.0 to 1.0)
return
uint32_t
Color at the position

Render Loop

fern_set_draw_callback()

void fern_set_draw_callback(FernDrawCallback callback)
Sets the draw callback function for the render loop.
callback
FernDrawCallback
required
Function pointer to draw callback

fern_start_render_loop()

void fern_start_render_loop(void)
Starts the main render loop (WebAssembly only).

Input Functions

update_mouse_position()

void update_mouse_position(int x, int y)
Updates the mouse position (called by event handlers).

update_mouse_button()

void update_mouse_button(int down)
Updates the mouse button state (called by event handlers).

reset_input_events()

void reset_input_events(void)
Resets frame-specific input events.

Utility Functions

fernPrintf()

void fernPrintf(const char* string)
Prints a debug message to console.
string
const char*
required
Message to print

Example Usage

#include <stdint.h>

// Create canvas
uint32_t pixels[800 * 600];
FernCanvas canvas = { pixels, 600, 800 };

// Draw callback
void draw() {
    ffill(canvas.pixels, canvas.height, canvas.width, Colors_gray);
    
    Container(Colors_blue, 50, 50, 200, 100);
    CircleWidget(25, Point_create(150, 100), Colors_red);
    TextWidget(Point_create(100, 200), "HELLO", 2, Colors_white);
}

int main() {
    runApp(canvas);
    fern_set_draw_callback(draw);
    fern_start_render_loop();
    return 0;
}

Build docs developers (and LLMs) love