1.0.0 (#1)

Author: mcpcpc

.gitignore

@@ -0,0 +1,2 @@
+gb
+*.o

Makefile

@@ -0,0 +1,35 @@
+.POSIX:
+.SUFFIXES:
+
+include config.mk
+
+CFLAGS += -std=c99 -Wall -Wextra -Wno-unused-parameter
+CFLAGS += -g -Iinclude -Isrc -I.
+
+SRC = src
+OBJ = main.o book.o order.o strategy.o
+
+all: gb
+
+gb: $(OBJ)
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+%.o: $(SRC)/%.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f gb *.o
+
+install:
+	mkdir -p $(DESTDIR)$(BINDIR)
+	cp -f gb $(DESTDIR)$(BINDIR)
+	chmod 755 $(DESTDIR)$(BINDIR)/gb
+	mkdir -p $(DESTDIR)$(MANDIR)/man1
+	cp -f gb.1 $(DESTDIR)$(MANDIR)/man1
+	chmod 644 $(DESTDIR)$(MANDIR)/man1/gb.1
+
+uninstall:
+	rm -f $(DESTDIR)$(BINDIR)/gb
+	rm -f $(DESTDIR)$(MANDIR)/man1/gb.1
+
+.PHONY: all clean install uninstall

README.md

@@ -0,0 +1,60 @@
+gb
+==
+
+*gb* is a real-time, command-line grid trading bot written in C99. It adheres to the Suckless philosophy: simple, modular, and minimal. The bot reads price data from standard input and writes order fills and status updates to standard output. All state is in-memory, and configuration is passed via command-line flags. No sockets, no threads, no dependencies.
+
+Features
+--------
+
+- Single static binary
+- No external libraries or socket connections
+- Fully pipeable: integrates with Unix tools or other processes
+- Designed for real-time use
+
+Usage
+-----
+
+Run:
+
+    ./gb [options]
+
+Price ticks are fed line-by-line through standard input, and order events are emitted through standard output.
+
+For full command-line options and usage details, see:
+
+    man gb
+
+Example:
+
+    $ echo -e "99\n100\n101" | ./gb -c 100 -l 3 -s 1 -q 0.5
+
+Output:
+
+    TICK 1 @ 99.00
+    Filled BUY 99.00 x 0.50
+
+    TICK 2 @ 100.00
+
+    TICK 3 @ 101.00
+    Filled SELL 101.00 x 0.50
+
+Build
+-----
+
+    make clean && make
+    
+
+Produces the `./gb` binary. Requires only a POSIX-compatible C compiler (e.g., `cc` or `clang`).
+
+Backtesting
+-----------
+
+Backtesting is not part of this binary and should be done externally (e.g., via Python with `backtesting.py`).
+
+Philosophy
+----------
+
+- No bloat. All logic lives in C99 source files under 500 lines.
+- No runtime configuration files or databases.
+- No sockets, threads, JSON, XML, or other overhead.
+- Everything via `stdin` / `stdout`.

config.def.h

@@ -0,0 +1,11 @@
+#ifndef CONFIG_DEF_H
+#define CONFIG_DEF_H
+
+#define DEFAULT_CENTER 100.0
+#define DEFAULT_LEVELS 5
+#define DEFAULT_SPACING 1.0
+#define DEFAULT_QUANTITY 1.0
+
+#define MAX_LINE_LENGTH 128
+
+#endif

config.mk

@@ -0,0 +1,7 @@
+# config.mk - default build configuration
+
+PREFIX = /usr/local
+BINDIR = $(PREFIX)/bin
+MANDIR = $(PREFIX)/share/man
+
+CC = cc

gb.1

@@ -0,0 +1,93 @@
+.TH GB 1 "July 2025" "Grid Bot 1.0" "User Commands"
+
+.SH NAME
+gb \- real-time grid trading bot for stdin/stdout streaming
+
+.SH SYNOPSIS
+.B gb
+[\-c center] [\-l levels] [\-s spacing] [\-q quantity] [\-d]
+
+.SH DESCRIPTION
+.B gb
+is a lightweight, suckless-aligned, real-time grid trading bot that reads price data from standard input and emits order activity, fills, and strategy state to standard output.
+
+All configuration is passed via command-line options, and the program operates as a single binary with no external dependencies, sockets, or persistent state.
+
+.SH OPTIONS
+.TP
+.B \-c
+Set the center price for the grid (default: 100.0).
+.TP
+.B \-l
+Number of grid levels per side (default: 5).
+.TP
+.B \-s
+Grid spacing between levels (default: 1.0).
+.TP
+.B \-q
+Quantity per order (default: 1.0).
+.TP
+.B \-d
+Enable debug mode. Prints full strategy status after each tick.
+.TP
+.B \-h
+Print usage help and exit.
+
+.SH INPUT
+The program expects newline-delimited price ticks via standard input:
+.PP
+.EX
+98.5
+99.0
+100.2
+.EE
+
+.SH OUTPUT
+For each tick, gb prints a status report including:
+.TP
+.B Order fills:
+e.g., "Filled BUY 98.00 x 1.00"
+.TP
+.B New orders:
+Automatically placed grid orders above/below fill prices.
+.TP
+.B PnL and Position:
+Realized profit and open quantity (only shown if
+.B -d
+is specified).
+
+.SH EXAMPLES
+Basic usage:
+.PP
+.EX
+$ ./gb -c 100 -l 3 -s 1 -q 1 < prices.txt
+.EE
+
+Enable debug mode:
+.PP
+.EX
+$ ./gb -c 100 -l 3 -s 1 -q 1 -d
+.EE
+
+Pipe live price data:
+.PP
+.EX
+$ while true; do get_price; sleep 1; done | ./gb -c 90 -l 4 -s 0.5 -q 1 -d
+.EE
+
+.SH FILES
+None. All interaction is via standard input/output.
+
+.SH LIMITATIONS
+This implementation performs no order matching, persistence, or time-aware logic. Backtesting and visualizations should be performed externally.
+
+.SH SEE ALSO
+.BR backtesting (1),
+.BR awk (1),
+.BR python (1)
+
+.SH AUTHOR
+Michael Czigler <[email protected]>
+
+.SH LICENSE
+BSD 3-Clause License. See LICENSE file for details.

include/gb.h

@@ -0,0 +1,11 @@
+#ifndef GB_H
+#define GB_H
+
+#define _POSIX_C_SOURCE 200112L
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#endif // GB_H

src/book.c

@@ -0,0 +1,68 @@
+#include "book.h"
+
+book_t *book_create(void) {
+    book_t *book = malloc(sizeof(book_t));
+    if (book == NULL) return NULL;
+    book->head = NULL;
+    return book;
+}
+
+void book_free(book_t *book) {
+    if (book == NULL) return;
+    order_t *curr = book->head;
+    while (curr != NULL) {
+        order_t *tmp = curr->next;
+        order_free(curr);
+        curr = tmp;
+    }
+    free(book);
+}
+
+void book_add_order(book_t *book, order_t *order) {
+    if ((book == NULL) || (order == NULL)) return;
+    order->next = book->head;
+    book->head = order;
+}
+
+order_t * book_remove_order(book_t *book, double price,
+        order_type_t type) {
+    if ((book == NULL) || (book->head == NULL))
+        return NULL;
+    order_t *prev = NULL;
+    order_t *curr = book->head;
+    while (curr != NULL) {
+        if (curr->price == price && curr->type == type) {
+            if (prev != NULL) {
+                prev->next = curr->next;
+            } else {
+                book->head = curr->next;
+            }
+            curr->next = NULL;
+            return curr;
+        }
+        prev = curr;
+        curr = curr->next;
+    }
+
+    return NULL;
+}
+
+int book_contains_order(book_t *book, double price, 
+        order_type_t type) {
+    order_t *curr = book->head;
+    while (curr != NULL) {
+        if (curr->price == price && curr->type == type) {
+            return 1;
+        }
+        curr = curr->next;
+    }
+    return 0;
+}
+
+void book_print(const book_t *book) {
+    const order_t *curr = book->head;
+    while (curr != NULL) {
+        order_print(curr);
+        curr = curr->next;
+    }
+}

src/book.h

@@ -0,0 +1,21 @@
+#ifndef BOOK_H
+#define BOOK_H
+
+#include "gb.h"
+#include "order.h"
+
+typedef struct BOOK {
+    order_t *head;
+} book_t;
+
+book_t *book_create(void);
+void book_free(book_t *book);
+
+void book_add_order(book_t *book, order_t *order);
+order_t *book_remove_order(book_t *book, double price,
+        order_type_t type);
+int book_contains_order(book_t *book, double price,
+        order_type_t type);
+void book_print(const book_t *book);
+
+#endif // BOOK_H

src/main.c

@@ -0,0 +1,48 @@
+#include "strategy.h"
+#include "config.def.h"
+
+static void usage(const char *prog) {
+    fprintf(stderr,
+        "Usage: %s [-c center] [-l levels] [-s spacing] [-q quantity] [-d]\n", prog);
+    exit(1);
+}
+
+int main(int argc, char *argv[]) {
+    double center = DEFAULT_CENTER;
+    int levels = DEFAULT_LEVELS;
+    double spacing = DEFAULT_SPACING;
+    double quantity = DEFAULT_QUANTITY;
+
+    int opt, debug = 0, tick = 0;
+    while ((opt = getopt(argc, argv, "c:l:s:q:dh")) != -1) {
+        switch (opt) {
+        case 'c': center = atof(optarg); break;
+        case 'l': levels = atoi(optarg); break;
+        case 's': spacing = atof(optarg); break;
+        case 'q': quantity = atof(optarg); break;
+        case 'd': ++debug; break;
+        case 'h': default: usage(argv[0]);
+        }
+    }
+
+    strategy_t *strategy = strategy_create(center,
+        levels, spacing, quantity);
+    if (strategy == NULL) {
+        fputs("Failed to initialize strategy.\n", stderr);
+        return 1;
+    }
+
+    char line[MAX_LINE_LENGTH];
+    while (fgets(line, sizeof(line), stdin)) {
+        double price = atof(line);
+        printf("\nTICK %d @ %.2f\n", ++tick, price);
+        strategy_on_tick(strategy, price);
+        if (debug > 0) {
+            strategy_print_status(strategy);
+        }
+        fflush(stdout);
+    }
+
+    strategy_free(strategy);
+    return 0;
+}