Add C17 and C23 builds with comprehensive benchmarking

- Update Makefile to build both C17 and C23 versions
- C23 falls back to c2x flag for older compilers
- Update benchmark script to test all three versions (C17, C23, Zig)
- Fix Zig line reading to use takeDelimiter for proper multi-line input
- Update CI to test both C versions
- All versions now produce identical output

Author: vinitkumar

.github/workflows/zig.yml

@@ -13,11 +13,22 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
-    - name: Build C version
+    - name: Check GCC version
+      run: gcc --version
+    
+    - name: Build C versions (C17 and C23)
       run: cd c && make clean && make
 
-    - name: Test C executable runs
-      run: cd c && echo -e "hi\npython\nexit" | timeout 5 ./chat || true
+    - name: Test C17 executable runs
+      run: cd c && echo -e "hi\npython\nexit" | timeout 5 ./chat-c17 || true
+    
+    - name: Test C23 executable runs
+      run: cd c && echo -e "hi\npython\nexit" | timeout 5 ./chat-c23 || true
+    
+    - name: Compare binary sizes
+      run: |
+        echo "Binary sizes:"
+        ls -lh c/chat-c17 c/chat-c23
 
   zig-build-and-test:
     runs-on: ubuntu-latest
@@ -30,10 +41,13 @@ jobs:
         version: 0.15.2
 
     - name: Build Zig chatbot
-      run: cd zig && mkdir -p zig-out/bin && zig build-exe src/main.zig -femit-bin=zig-out/bin/chat
+      run: cd zig && zig build
 
     - name: Run Zig tests
-      run: cd zig && zig test src/chatbot.zig
+      run: cd zig && zig build test
 
     - name: Test Zig executable runs
       run: cd zig && echo -e "hi\npython\nexit" | timeout 5 ./zig-out/bin/chat || true
+    
+    - name: Show binary size
+      run: ls -lh zig/zig-out/bin/chat

BENCHMARK.md

@@ -1,48 +1,62 @@
-# Chatbot Build Benchmark Results
+# Chatbot Build & Runtime Benchmark Results
 
-Benchmark comparing C and Zig implementations of the chatbot.
+Benchmark comparing C (C17 and C23 standards) and Zig implementations of the chatbot.
 
 **System:** macOS arm64  
 **Date:** 2026-01-12
 
-## Results
+## Build Results
 
-| Metric | C | Zig | Difference |
-|--------|---|-----|-----------|
-| Build Time | 93ms | 710ms | Zig is 7.63x slower |
-| Executable Size | 33K | 1.3M | Zig is 39x larger |
+| Metric | C17 | C23 | Zig | Notes |
+|--------|-----|-----|-----|-------|
+| Build Time | ~90ms | ~90ms | ~710ms | Zig ~8x slower |
+| Executable Size | 33K | 33K | 1.3M | Zig ~40x larger |
+
+## Runtime Results
+
+| Version | Execution Time | Relative |
+|---------|---------------|----------|
+| C17 | 147ms | 1.00x |
+| C23 | 197ms | 1.34x |
+| Zig | 459ms | 3.12x |
 
 ## Analysis
 
 ### Build Time
-- **C (93ms)**: Fast compilation using GCC with minimal optimization
-- **Zig (710ms)**: Longer compilation time due to Zig's more comprehensive compiler
-
-The C version compiles significantly faster due to:
-- Simpler compilation pipeline
-- No build system overhead (direct gcc command)
-- Minimal type checking and analysis
+- **C (C17/C23)**: Fast compilation using GCC with minimal optimization
+- **Zig**: Longer compilation time due to more comprehensive compiler
 
 ### Executable Size
-- **C (33K)**: Small, minimal runtime
-- **Zig (1.3M)**: Larger due to Zig's standard library and runtime
+- **C (33K)**: Small, minimal runtime, links against system libc
+- **Zig (1.3M)**: Larger due to embedded standard library and runtime
+
+### Runtime Performance
+- **C17** is the fastest, likely due to mature compiler optimizations
+- **C23** is slightly slower (may vary based on compiler version)
+- **Zig** is slower due to:
+  - GeneralPurposeAllocator overhead vs C's stack allocation
+  - New Zig 0.15 buffered I/O system overhead
+  - Additional safety checks
 
-The Zig executable is larger because:
-- Zig stdlib is embedded in the binary
-- More comprehensive runtime features
-- GeneralPurposeAllocator adds overhead
+## Build Configuration
+
+- **C17**: `gcc -std=c17 -Wall -Wextra -pedantic`
+- **C23**: `gcc -std=c23 -Wall -Wextra -pedantic` (falls back to `-std=c2x` on older compilers)
+- **Zig**: `zig build` (debug mode, Zig 0.15.2)
 
 ## Notes
 
-- Both versions are unoptimized builds
-- C build uses `-std=c11 -Wall -Wextra -pedantic`
-- Zig build uses default optimization level
+- All versions produce identical output
 - Times are from cold builds (no cache)
+- Runtime measured with same test input file
+- Zig uses pure Zig I/O (no libc linking)
 
-## Running the Benchmark
+## Running the Benchmarks
 
 ```bash
+# Full runtime benchmark
+./run_benchmarks.sh
+
+# Build-only benchmark
 ./benchmark.sh
 ```
-
-This will clean, rebuild both versions, and compare build times and sizes.

c/Makefile

@@ -1,5 +1,19 @@
-all:
-	gcc -std=c11 -Wall -Wextra -pedantic src/chatbot.c -o chat
+CC = gcc
+CFLAGS_COMMON = -Wall -Wextra -pedantic
+SRC = src/chatbot.c
+
+all: chat-c17 chat-c23
+
+chat-c17:
+	$(CC) -std=c17 $(CFLAGS_COMMON) $(SRC) -o chat-c17
+
+chat-c23:
+	$(CC) -std=c23 $(CFLAGS_COMMON) $(SRC) -o chat-c23 2>/dev/null || \
+	$(CC) -std=c2x $(CFLAGS_COMMON) $(SRC) -o chat-c23
+
+# Legacy target for backwards compatibility
+chat: chat-c17
+	cp chat-c17 chat
 
 clean:
-	rm -rf *.o chat
+	rm -rf *.o chat chat-c17 chat-c23

run_benchmarks.sh

@@ -7,8 +7,8 @@ echo "Chatbot Runtime Benchmark & Testing"
 echo "=========================================="
 echo ""
 
-# Build both versions
-echo "Building both versions..."
+# Build all versions
+echo "Building all versions..."
 echo ""
 
 cd c
@@ -19,28 +19,46 @@ cd ..
 cd zig
 rm -rf zig-out .zig-cache > /dev/null 2>&1
 mkdir -p zig-out/bin
-zig build-exe src/main.zig -femit-bin=zig-out/bin/chat > /dev/null 2>&1
+zig build > /dev/null 2>&1
 cd ..
 
 echo "Build complete!"
 echo ""
 
-# Test C version
+# Test C17 version
 echo "=========================================="
-echo "C Version Testing & Benchmarking"
+echo "C17 Version Testing & Benchmarking"
 echo "=========================================="
 echo ""
 echo "Running with test inputs..."
 
-C_START=$(date +%s%N)
-c/./chat < test_inputs.txt > /tmp/c_output.txt 2>&1
-C_END=$(date +%s%N)
-C_TIME=$(( (C_END - C_START) / 1000000 ))  # milliseconds
+C17_START=$(date +%s%N)
+c/./chat-c17 < test_inputs.txt > /tmp/c17_output.txt 2>&1
+C17_END=$(date +%s%N)
+C17_TIME=$(( (C17_END - C17_START) / 1000000 ))  # milliseconds
 
 echo "Output:"
-cat /tmp/c_output.txt
+cat /tmp/c17_output.txt
 echo ""
-echo "Execution time: ${C_TIME}ms"
+echo "Execution time: ${C17_TIME}ms"
+echo ""
+
+# Test C23 version
+echo "=========================================="
+echo "C23 Version Testing & Benchmarking"
+echo "=========================================="
+echo ""
+echo "Running with test inputs..."
+
+C23_START=$(date +%s%N)
+c/./chat-c23 < test_inputs.txt > /tmp/c23_output.txt 2>&1
+C23_END=$(date +%s%N)
+C23_TIME=$(( (C23_END - C23_START) / 1000000 ))  # milliseconds
+
+echo "Output:"
+cat /tmp/c23_output.txt
+echo ""
+echo "Execution time: ${C23_TIME}ms"
 echo ""
 
 # Test Zig version
@@ -67,16 +85,19 @@ echo "Output Comparison"
 echo "=========================================="
 echo ""
 
-if diff -q /tmp/c_output.txt /tmp/zig_output.txt > /dev/null 2>&1; then
-  echo "✓ Outputs are identical"
+OUTPUTS_MATCH=true
+if diff -q /tmp/c17_output.txt /tmp/c23_output.txt > /dev/null 2>&1; then
+  echo "✓ C17 and C23 outputs are identical"
 else
-  echo "✗ Outputs differ"
-  echo ""
-  echo "C output:"
-  cat /tmp/c_output.txt
-  echo ""
-  echo "Zig output:"
-  cat /tmp/zig_output.txt
+  echo "✗ C17 and C23 outputs differ"
+  OUTPUTS_MATCH=false
+fi
+
+if diff -q /tmp/c17_output.txt /tmp/zig_output.txt > /dev/null 2>&1; then
+  echo "✓ C17 and Zig outputs are identical"
+else
+  echo "✗ C17 and Zig outputs differ"
+  OUTPUTS_MATCH=false
 fi
 
 echo ""
@@ -87,16 +108,47 @@ echo "Runtime Comparison"
 echo "=========================================="
 echo ""
 
-if [ $C_TIME -lt $ZIG_TIME ]; then
-  RATIO=$(echo "scale=2; $ZIG_TIME / $C_TIME" | bc)
-  echo "C version is ${RATIO}x faster"
-else
-  RATIO=$(echo "scale=2; $C_TIME / $ZIG_TIME" | bc)
-  echo "Zig version is ${RATIO}x faster"
+# Find the fastest
+MIN_TIME=$C17_TIME
+FASTEST="C17"
+if [ $C23_TIME -lt $MIN_TIME ]; then
+  MIN_TIME=$C23_TIME
+  FASTEST="C23"
+fi
+if [ $ZIG_TIME -lt $MIN_TIME ]; then
+  MIN_TIME=$ZIG_TIME
+  FASTEST="Zig"
 fi
 
+echo "Fastest: $FASTEST (${MIN_TIME}ms)"
 echo ""
 echo "Summary:"
-echo "  C:   ${C_TIME}ms"
+echo "  C17: ${C17_TIME}ms"
+echo "  C23: ${C23_TIME}ms"
 echo "  Zig: ${ZIG_TIME}ms"
 echo ""
+
+# Show ratios relative to fastest
+if [ $MIN_TIME -gt 0 ]; then
+  C17_RATIO=$(echo "scale=2; $C17_TIME / $MIN_TIME" | bc)
+  C23_RATIO=$(echo "scale=2; $C23_TIME / $MIN_TIME" | bc)
+  ZIG_RATIO=$(echo "scale=2; $ZIG_TIME / $MIN_TIME" | bc)
+  echo "Relative to fastest:"
+  echo "  C17: ${C17_RATIO}x"
+  echo "  C23: ${C23_RATIO}x"
+  echo "  Zig: ${ZIG_RATIO}x"
+  echo ""
+fi
+
+# Binary sizes
+echo "=========================================="
+echo "Binary Sizes"
+echo "=========================================="
+echo ""
+C17_SIZE=$(ls -lh c/chat-c17 | awk '{print $5}')
+C23_SIZE=$(ls -lh c/chat-c23 | awk '{print $5}')
+ZIG_SIZE=$(ls -lh zig/zig-out/bin/chat | awk '{print $5}')
+echo "  C17: $C17_SIZE"
+echo "  C23: $C23_SIZE"
+echo "  Zig: $ZIG_SIZE"
+echo ""

zig/src/main.zig

@@ -33,9 +33,9 @@ pub fn main() !void {
         try stdout.interface.flush();
 
         // Read line using Zig 0.15 delimiter API
-        const line = stdin.interface.takeDelimiterExclusive('\n') catch |err| {
+        // Use takeDelimiter which returns null on EOF with empty remaining
+        const line = stdin.interface.takeDelimiter('\n') catch |err| {
             switch (err) {
-                error.EndOfStream => break,
                 error.StreamTooLong => {
                     // Line too long, skip it
                     continue;
@@ -44,8 +44,10 @@ pub fn main() !void {
             }
         };
 
-        const trimmed = std.mem.trim(u8, line, " \t\r\n");
-        if (trimmed.len == 0) break;
+        if (line == null) break;
+
+        const trimmed = std.mem.trim(u8, line.?, " \t\r\n");
+        if (trimmed.len == 0) continue; // Empty line, keep going
 
         var word_iter = std.mem.tokenizeAny(u8, trimmed, chatbot.SeparatorChars);