├── examples
    ├── config.nims
    ├── white_noise.nim
    ├── mouse_buttons.nim
    ├── colorful_patterns.nim
    ├── square_patterns.nim
    ├── bubbles_patterns.nim
    ├── red_square.nim
    ├── plasma.nim
    ├── simple_mouse_drawing.nim
    ├── audio.nim
    ├── interactive_julia_set.nim
    ├── conways_game_of_life.nim
    ├── walkable_carpet.nim
    ├── audio_bytebeats.nim
    ├── mandelbrot.nim
    └── threaded_mandelbrot.nim
├── .gitmodules
├── fenstim.nimble
├── LICENSE
├── .github
    └── workflows
    │   └── blank.yml
├── src
    ├── fenstim_audio.nim
    └── fenstim.nim
└── README.md


/examples/config.nims:
--------------------------------------------------------------------------------
1 | switch("path", "$projectDir/../src")


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "src/fensterb"]
2 | 	path = src/fensterb
3 | 	url = https://github.com/h3rald/fensterb/
4 | 


--------------------------------------------------------------------------------
/examples/white_noise.nim:
--------------------------------------------------------------------------------
1 | import fenstim, random
2 | 
3 | var app = init(Fenster, "White noise with fenstim", 800, 600)
4 | 
5 | while app.loop and app.keys[27] == 0:
6 |   for x in 0 ..< app.width:
7 |     for y in 0 ..< app.height:
8 |       app.pixel(x, y) = rand(uint32)


--------------------------------------------------------------------------------
/fenstim.nimble:
--------------------------------------------------------------------------------
 1 | # Package
 2 | 
 3 | version = "1.0.3"
 4 | author = "Comunity"
 5 | description = "The most minimal cross-platform GUI library - in Nim"
 6 | skipDirs = @["examples"]
 7 | license = "MIT"
 8 | 
 9 | # Deps
10 | requires "nim >= 1.0.0"
11 | 
12 | srcDir = "src"
13 | 


--------------------------------------------------------------------------------
/examples/mouse_buttons.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, strutils
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Mouse Buttons test", 800, 600)
 5 |   oldmouse = app.mouse
 6 | 
 7 | while app.loop and app.keys[27] == 0:
 8 |   if oldmouse != app.mouse:
 9 |     oldmouse = app.mouse
10 |     echo app.mouse
11 | 


--------------------------------------------------------------------------------
/examples/colorful_patterns.nim:
--------------------------------------------------------------------------------
 1 | import fenstim
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Colorful patterns", 320, 240)
 5 |   t = 1
 6 | 
 7 | while app.loop and app.keys[27] == 0:
 8 |   t += 1
 9 |   for i in 0..<app.width:
10 |     for j in 0..<app.height:
11 |       app.pixel(i, j) = (i * j * t).uint32


--------------------------------------------------------------------------------
/examples/square_patterns.nim:
--------------------------------------------------------------------------------
 1 | import fenstim
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Square patterns", 320, 240)
 5 |   t = 1
 6 | 
 7 | while app.loop and app.keys[27] == 0:
 8 |   t += 1
 9 |   for i in 0..<app.width:
10 |     for j in 0..<app.height:
11 |       app.pixel(i, j) = uint32((i xor j xor t) * 65793)


--------------------------------------------------------------------------------
/examples/bubbles_patterns.nim:
--------------------------------------------------------------------------------
 1 | import fenstim
 2 | 
 3 | var app = init(Fenster, "Bubbles pattern", 320, 240)
 4 | var t = 0
 5 | 
 6 | while app.loop and app.keys[27] == 0:
 7 |   inc t
 8 |   for x in 0..<app.width:
 9 |     for y in 0..<app.height:
10 |       app.pixel(x, y) = uint32(((x * x + y * y + t) and 255) * 0x010101)


--------------------------------------------------------------------------------
/examples/red_square.nim:
--------------------------------------------------------------------------------
 1 | import fenstim
 2 | 
 3 | var app = init(Fenster, "Red square with fenstim", 800, 600)
 4 | 
 5 | while app.loop and app.keys[27] == 0:
 6 |   for x in 350 .. 450:
 7 |     for y in 250 .. 350:
 8 |       #You can alternatively enter “0xFF0000” but the stored value will still be decimal.
 9 |       #app.pixel(x, y) = colRed (with import colors)
10 |       app.pixel(x, y) = 16711680


--------------------------------------------------------------------------------
/examples/plasma.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, math
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Plasma", 320, 240)
 5 |   t = 0.0
 6 | 
 7 | while app.loop and app.keys[27] == 0:
 8 |   t += 0.1
 9 |   for i in 0..<app.width:
10 |     for j in 0..<app.height:
11 |       let plasma = sin(i.float * 0.04 + t) + sin(j.float * 0.03) + sin((i.float + j.float) * 0.02 + t)
12 |       let color = uint32((plasma + 3) * 85)
13 |       app.pixel(i, j) = color shl 16 or (color shl 1) shl 8 or color shl 2


--------------------------------------------------------------------------------
/examples/simple_mouse_drawing.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, random
 2 | 
 3 | var
 4 |   app = init(Fenster, "Draw on mouse click. Change color with W key", 800, 600)
 5 |   currentColor = 0xFF0000.uint32
 6 | 
 7 | while app.loop and app.keys[27] == 0:
 8 | 
 9 |   if app.keys[ord('W')] == 1:
10 |     currentColor = rand(uint32)
11 | 
12 |   if app.mouse.mhold[0] == 1:
13 |     let x = clamp(app.mouse.pos.x, 0, app.width)
14 |     let y = clamp(app.mouse.pos.y, 0, app.height)
15 |     app.pixel(x, y) = currentColor


--------------------------------------------------------------------------------
/examples/audio.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, fenstim_audio
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Audio Example", 320, 240, 60)
 5 |   app_audio = init(FensterAudio)
 6 |   t, u = 0
 7 | 
 8 | proc generateAudio(n: int): seq[float32] =
 9 |   result = newSeq[float32](n)
10 |   for i in 0..<n:
11 |     u.inc
12 |     let x = (u * 80 div 441).int
13 |     result[i] = float32(((((x shr 10) and 42) * x) and 0xff)) / 256.0
14 | 
15 | while app.loop and app.keys[27] == 0:
16 |   t.inc
17 | 
18 |   let n = app_audio.available
19 |   if n > 0:
20 |     let audio = generateAudio(n)
21 |     app_audio.write(audio)
22 | 
23 |   for i in 0..<app.width:
24 |     for j in 0..<app.height:
25 |       app.pixel(i, j) = (i * j * t).uint32


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Cardeal Russo
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/interactive_julia_set.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, math
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Interactive Julia Set", 800, 600, 60)
 5 |   cx, cy: float32 = 0
 6 |   oldpos = (801, 601)
 7 | 
 8 | proc julia(x, y, cx, cy: float32, maxIter: int): int =
 9 |   var 
10 |     zx = x
11 |     zy = y
12 | 
13 |   for i in 1..maxIter:
14 |     let
15 |       zx2 = zx*zx
16 |       zy2 = zy*zy
17 | 
18 |     if zx2 + zy2 > 4: return i
19 | 
20 |     zy = 2*zx*zy + cy
21 |     zx = zx2 - zy2 + cx
22 | 
23 |   return 0
24 | 
25 | while app.loop and app.keys[27] == 0:
26 |   let (mouseX, mouseY) = app.mouse.pos
27 |   if (mouseX, mouseY) != oldpos:
28 |     oldpos = (mouseX, mouseY)
29 |     cx = mouseX.float32 / app.width.float32 * 4 - 2
30 |     cy = mouseY.float32 / app.height.float32 * 4 - 2
31 | 
32 |     for px in 0..<app.width:
33 |       for py in 0..<app.height:
34 |         let 
35 |           x = px.float32 / app.width.float32 * 4 - 2
36 |           y = py.float32 / app.height.float32 * 4 - 2
37 |           c = julia(x, y, cx, cy, 100)
38 |           r = uint8((sin(c.float32 * 0.1) + 1) * 127)
39 |           g = uint8((sin(c.float32 * 0.13 + 1) + 1) * 127)
40 |           b = uint8((sin(c.float32 * 0.17 + 2) + 1) * 127)
41 | 
42 |         app.pixel(px, py) = (r.uint32 shl 16) or (g.uint32 shl 8) or b.uint32


--------------------------------------------------------------------------------
/.github/workflows/blank.yml:
--------------------------------------------------------------------------------
 1 | name: Compile Fenstim Examples
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 |   workflow_dispatch:
 9 | 
10 | jobs:
11 |   build:
12 |     strategy:
13 |       matrix:
14 |         os: [ubuntu-latest, windows-latest, macOS-latest]
15 |     runs-on: ${{ matrix.os }}
16 | 
17 |     steps:
18 |     - uses: actions/checkout@v4
19 |       with:
20 |         submodules: 'recursive'
21 | 
22 |     - name: Set up Nim
23 |       uses: jiro4989/setup-nim-action@v1
24 |       with:
25 |         nim-version: 'stable'
26 | 
27 |     - name: Install dependencies on Ubuntu
28 |       if: matrix.os == 'ubuntu-latest'
29 |       run: sudo apt-get install -y libasound2-dev
30 |       shell: bash
31 | 
32 |     - name: Create build directory
33 |       run: mkdir build
34 |       shell: bash
35 | 
36 |     - name: Compile Examples
37 |       run: |
38 |         for file in examples/*.nim; do
39 |           filename=$(basename "$file" .nim)
40 |           echo "Compiling $filename"
41 |           nim c -f -d:danger -d:lto -d:strip --mm:arc --passC:"-march=native" -o:"build/${filename}_${{ runner.os }}" "$file"
42 |         done
43 |       shell: bash
44 | 
45 |     - name: Upload artifact
46 |       uses: actions/upload-artifact@v4
47 |       with:
48 |         name: fenstim-examples-${{ runner.os }}
49 |         path: build/
50 | 


--------------------------------------------------------------------------------
/examples/conways_game_of_life.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, random
 2 | 
 3 | const 
 4 |   WIDTH = 400
 5 |   HEIGHT = 300
 6 |   CELL_SIZE = 2
 7 | 
 8 | var 
 9 |   app = init(Fenster, "Conway's Game of Life", WIDTH * CELL_SIZE, HEIGHT * CELL_SIZE, 30)
10 |   grid: array[WIDTH, array[HEIGHT, bool]]
11 |   newGrid: array[WIDTH, array[HEIGHT, bool]]
12 | 
13 | randomize()
14 | 
15 | for x in 0..<WIDTH:
16 |   for y in 0..<HEIGHT:
17 |     grid[x][y] = rand(1.0) < 0.2
18 | 
19 | proc countNeighbors(x, y: int): int =
20 |   for dx in -1..1:
21 |     for dy in -1..1:
22 |       if dx == 0 and dy == 0: continue
23 |       let
24 |         nx = (x + dx + WIDTH) mod WIDTH
25 |         ny = (y + dy + HEIGHT) mod HEIGHT
26 |       if grid[nx][ny]: result += 1
27 | 
28 | while app.loop and app.keys[27] == 0:
29 |   for x in 0..<WIDTH:
30 |     for y in 0..<HEIGHT:
31 |       let neighbors = countNeighbors(x, y)
32 |       if grid[x][y]:
33 |         newGrid[x][y] = neighbors == 2 or neighbors == 3
34 |       else:
35 |         newGrid[x][y] = neighbors == 3
36 |   
37 |   for x in 0..<WIDTH:
38 |     for y in 0..<HEIGHT:
39 |       grid[x][y] = newGrid[x][y]
40 |       let color = if grid[x][y]: 0xFFFFFF else: 0x000000
41 |       for dx in 0..<CELL_SIZE:
42 |         for dy in 0..<CELL_SIZE:
43 |           app.pixel(x * CELL_SIZE + dx, y * CELL_SIZE + dy) = color.uint32
44 | 
45 |   if app.keys[ord('R')] == 1:
46 |     for x in 0..<WIDTH:
47 |       for y in 0..<HEIGHT:
48 |         grid[x][y] = rand(1.0) < 0.2


--------------------------------------------------------------------------------
/examples/walkable_carpet.nim:
--------------------------------------------------------------------------------
 1 | import fenstim
 2 | 
 3 | const 
 4 |   WIDTH = 800
 5 |   HEIGHT = 600
 6 |   FPS = 60
 7 | 
 8 | var 
 9 |   app = init(Fenster, "Walkable Carpet Pattern", WIDTH, HEIGHT, FPS)
10 |   offsetX, offsetY = 0
11 |   lastMouseCords = (app.mouse.pos.x, app.mouse.pos.y)
12 | 
13 | proc movingCarpetPattern(x, y: int, mouseX, mouseY: float32): uint32 =
14 |   let
15 |     smoothOffsetX = (mouseX / WIDTH.float32 * 20).int
16 |     smoothOffsetY = (mouseY / HEIGHT.float32 * 20).int
17 |     
18 |     adjustedX = (x + smoothOffsetX + offsetX) div 20
19 |     adjustedY = (y + smoothOffsetY + offsetY) div 20
20 |     
21 |     isEvenSquare = (adjustedX + adjustedY) mod 2 == 0
22 |     color = if isEvenSquare: 0xD2691E else: 0x8B4513
23 | 
24 |   return color.uint32
25 | 
26 | proc updateOffset() =
27 |   const MOVE_SPEED = 5
28 |   if app.keys[ord('W')] == 1: offsetY -= MOVE_SPEED
29 |   if app.keys[ord('S')] == 1: offsetY += MOVE_SPEED
30 |   if app.keys[ord('A')] == 1: offsetX -= MOVE_SPEED
31 |   if app.keys[ord('D')] == 1: offsetX += MOVE_SPEED
32 | 
33 | while app.loop and app.keys[27] == 0:
34 |   let mouseMoved = lastMouseCords != (app.mouse.pos.x, app.mouse.pos.y)
35 |   let movementKeysPressed = app.keys[ord('W')] == 1 or app.keys[ord('A')] == 1 or app.keys[ord('S')] == 1 or app.keys[ord('D')] == 1
36 | 
37 |   if mouseMoved or movementKeysPressed:
38 |     lastMouseCords = (app.mouse.pos.x, app.mouse.pos.y)
39 | 
40 |     updateOffset()
41 |   
42 |     for x in 0 ..< WIDTH:
43 |       for y in 0 ..< HEIGHT:
44 |         app.pixel(x, y) = movingCarpetPattern(x, y, app.mouse.pos.x.float32, app.mouse.pos.y.float32)
45 | 


--------------------------------------------------------------------------------
/src/fenstim_audio.nim:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | const fensterAudioHeader = currentSourcePath().parentDir() / "fensterb/src/fenster_audio/fenster_audio.h"
 4 | 
 5 | when defined(linux): {.passL: "-lasound".}
 6 | elif defined(windows): {.passL: "-lwinmm".}
 7 | elif defined(macosx): {.passL: "-framework AudioToolbox".}
 8 | 
 9 | {.passC: "-Ivendor".}
10 | 
11 | const FENSTER_AUDIO_BUFSZ = 8192
12 | 
13 | type
14 |   FensterAudioStruct  = object
15 |     audio_data: pointer
16 |     buf: array[FENSTER_AUDIO_BUFSZ, float32]
17 |     pos: csize_t
18 | 
19 |   FensterAudio* = object
20 |     raw: ptr FensterAudioStruct
21 | 
22 | {.push importc, header: fensterAudioHeader.}
23 | proc fenster_audio_open(fa: ptr FensterAudioStruct): cint
24 | proc fenster_audio_available(fa: ptr FensterAudioStruct): cint
25 | proc fenster_audio_write(fa: ptr FensterAudioStruct, buf: ptr float32, n: csize_t)
26 | proc fenster_audio_close(fa: ptr FensterAudioStruct)
27 | {.pop.}
28 | 
29 | proc close*(self: var FensterAudio) =
30 |   fenster_audio_close(self.raw)
31 |   dealloc(self.raw)
32 |   self.raw = nil
33 | 
34 | proc `=destroy`(self: FensterAudio) =
35 |   if self.raw != nil:
36 |     fenster_audio_close(self.raw)
37 |     dealloc(self.raw)
38 | 
39 | proc init*(_: type FensterAudio): FensterAudio =
40 |   result = FensterAudio()
41 |   result.raw = cast[ptr FensterAudioStruct](alloc0(sizeof(FensterAudioStruct)))
42 |   discard fenster_audio_open(result.raw)
43 | 
44 | proc available*(self: FensterAudio): int = fenster_audio_available(self.raw).int
45 | 
46 | proc write*(self: FensterAudio, buf: openArray[float32]) = fenster_audio_write(self.raw, unsafeAddr buf[0], buf.len.csize_t)
47 | 


--------------------------------------------------------------------------------
/examples/audio_bytebeats.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, fenstim_audio, math
 2 | 
 3 | var 
 4 |   app = init(Fenster, "Bytebeats. Switch with Left Click.", 800, 600, 60)
 5 |   app_audio = init(FensterAudio)
 6 |   t, u, currentBeat = 0
 7 | 
 8 | let byteBeats = [
 9 |   proc(x: int): float32 = float32(((((x shr 10) and 42) * x) and 0xff)) / 256.0,
10 |   proc(x: int): float32 = float32((x * ((x shr 12 or x shr 8) and 63 and x shr 4)) and 0xff) / 256.0,
11 |   proc(x: int): float32 = float32(((not (x shr 2)) * ((127 and x * (7 and x shr 10)) < (245 and x * (2 + (5 and x shr 14)))).int) and 0xff) / 256.0,
12 |   proc(x: int): float32 = float32((((x shr 10 xor x shr 11) mod 5 * ((x shr 14 and 3 xor x shr 15 and 1) + 1) * x mod 99 + ((3 + (x shr 14 and 3) - (x shr 16 and 1)) div 3 * x mod 99 and 64))) and 0xff) / 256.0
13 | ]
14 | 
15 | let arts = [
16 |   proc(x, y, t: int): uint32 = (x * y * t).uint32,
17 |   proc(x, y, t: int): uint32 = ((x xor y xor t) * 65793).uint32,
18 |   proc(x, y, t: int): uint32 = (((x * x + y * y + t) and 255) * 0x010101).uint32,
19 |   proc(x, y, t: int): uint32 = 
20 |   (
21 |     let freqX = 0.04 + app.mouse.pos.x / app.width * 0.1
22 |     let freqY = 0.03 + app.mouse.pos.y / app.height * 0.1
23 | 
24 |     let plasma = sin(x.float * freqX + 0.1 * t.float) + 
25 |              sin(y.float * freqY) + 
26 |              sin((x.float + y.float) * 0.02 + 0.1 * t.float)
27 |     
28 |     let color = uint32((plasma + 3) * 85)
29 |   
30 |     result = color shl 16 or (color shl 1) shl 8 or color shl 2
31 |   ),
32 | ]
33 | 
34 | proc generateAudio(n: int): seq[float32] =
35 |   result = newSeq[float32](n)
36 |   for i in 0..<n:
37 |     u.inc
38 |     result[i] = byteBeats[currentBeat]((u * 80 div 441).int)
39 | 
40 | while app.loop and app.keys[27] == 0:
41 |   t.inc
42 |   if app.mouse.mclick[0] == 1 or app.mouse.mclick[1] == 1:
43 |     currentBeat = (currentBeat + (if app.mouse.mclick[0] == 1: 1 else: -1) + byteBeats.len) mod byteBeats.len
44 |     echo "Switched to ByteBeat ", currentBeat + 1
45 |   
46 |   if app_audio.available > 0:
47 |     app_audio.write(generateAudio(app_audio.available))
48 |   
49 |   for i in 0..<app.width:
50 |     for j in 0..<app.height:
51 |       app.pixel(i, j) = arts[currentBeat](i, j, t)
52 | 


--------------------------------------------------------------------------------
/examples/mandelbrot.nim:
--------------------------------------------------------------------------------
 1 | import fenstim, math, random
 2 | 
 3 | randomize()
 4 | 
 5 | var 
 6 |   app = init(Fenster, "Efficient Edge-focusing single threaded Mandelbrot Set", 800, 600, 60)
 7 |   centerX, centerY: float64 = 0.0
 8 |   zoom: float64 = 1.0
 9 |   maxIterations = 100
10 |   zoomSpeed: float64 = 1.02
11 |   targetX, targetY: float64 = 0.0
12 | 
13 | proc mandelbrot(cx, cy: float64, maxIter: int): int =
14 |   var 
15 |     zx, zy, zx2, zy2: float64 = 0.0
16 |     x = cx
17 |     y = cy
18 | 
19 |   for i in 1..maxIter:
20 |     if zx2 + zy2 > 4.0: return i
21 |     zy = 2.0 * zx * zy + y
22 |     zx = zx2 - zy2 + x
23 |     zx2 = zx * zx
24 |     zy2 = zy * zy
25 | 
26 |   return maxIter
27 | 
28 | proc findInterestingArea(currX, currY, currZoom: float64): tuple[x, y: float64] =
29 |   const searchRadius = 2.0
30 |   const samples = 10
31 |   var bestX: float64 = currX
32 |   var bestY: float64 = currY
33 |   var bestScore = 0
34 | 
35 |   for _ in 0..<samples:
36 |     let
37 |       angle = rand(0.0..2*PI)
38 |       distance = rand(0.0..searchRadius) / currZoom
39 |       x = currX + cos(angle) * distance
40 |       y = currY + sin(angle) * distance
41 |       iterations = mandelbrot(x, y, maxIterations)
42 |     
43 |     # Consider points with iterations between 10 and maxIterations-10 as interesting
44 |     if iterations > 10 and iterations < maxIterations-10:
45 |       let score = maxIterations - abs(iterations - maxIterations div 2)
46 |       if score > bestScore:
47 |         bestScore = score
48 |         bestX = x
49 |         bestY = y
50 | 
51 |   if bestScore == 0:
52 |     # If no interesting point found, slightly move in a random direction
53 |     let angle = rand(0.0..2*PI)
54 |     bestX = currX + cos(angle) * (0.1 / currZoom)
55 |     bestY = currY + sin(angle) * (0.1 / currZoom)
56 | 
57 |   return (bestX, bestY)
58 | 
59 | proc draw() =
60 |   for px in 0..<app.width:
61 |     for py in 0..<app.height:
62 |       let 
63 |         x = (px.float64 - app.width.float64/2) / (0.25*zoom*app.width.float64) + centerX
64 |         y = (py.float64 - app.height.float64/2) / (0.25*zoom*app.height.float64) + centerY
65 |         c = mandelbrot(x, y, maxIterations)
66 |         r = uint8((sin(c.float64 * 0.1) + 1) * 127)
67 |         g = uint8((sin(c.float64 * 0.13 + 1) + 1) * 127)
68 |         b = uint8((sin(c.float64 * 0.17 + 2) + 1) * 127)
69 | 
70 |       app.pixel(px, py) = (r.uint32 shl 16) or (g.uint32 shl 8) or b.uint32
71 | 
72 | var frameCount: uint32 = 0
73 | 
74 | while app.loop and app.keys[27] == 0:
75 |   draw()
76 | 
77 |   # Continuous zoom
78 |   zoom *= zoomSpeed
79 |   
80 |   # Move towards target
81 |   centerX += (targetX - centerX) * 0.05
82 |   centerY += (targetY - centerY) * 0.05
83 | 
84 |   frameCount += 1
85 |   if frameCount mod 30 == 0:
86 |     (targetX, targetY) = findInterestingArea(centerX, centerY, zoom)
87 | 
88 |   maxIterations = int(100.0 * log10(zoom + 1))


--------------------------------------------------------------------------------
/src/fenstim.nim:
--------------------------------------------------------------------------------
  1 | import os
  2 | 
  3 | const fensterHeader = currentSourcePath().parentDir() / "fensterb/src/fenster/fenster.h"
  4 | 
  5 | when defined(linux): {.passl: "-lX11".}
  6 | elif defined(windows): {.passl: "-lgdi32".}
  7 | elif defined(macosx): {.passl: "-framework Cocoa".}
  8 | 
  9 | {.passC: "-Ivendor".}
 10 | 
 11 | type
 12 |   FensterStruct = object
 13 |     title*: cstring
 14 |     width*: cint
 15 |     height*: cint
 16 |     buf*: ptr UncheckedArray[uint32]
 17 |     keys*: array[256, cint]
 18 |     modkey*: cint
 19 |     x*: cint
 20 |     y*: cint
 21 |     mclick: array[5, cint]
 22 |     mhold: array[3, cint]
 23 |   
 24 |   Fenster* = object
 25 |     raw*: ptr FensterStruct
 26 |     targetFps*: int
 27 |     lastFrameTime*: int64
 28 |     fps*: float
 29 | 
 30 | {.push importc, header: fensterHeader.}
 31 | proc fenster_open(fenster: ptr FensterStruct): cint
 32 | proc fenster_loop(fenster: ptr FensterStruct): cint
 33 | proc fenster_close(fenster: ptr FensterStruct)
 34 | proc fenster_sleep(ms: cint)
 35 | proc fenster_time(): int64
 36 | {.pop.}
 37 | 
 38 | proc close*(self: var Fenster) =
 39 |   fenster_close(self.raw)
 40 |   dealloc(self.raw.buf)
 41 |   dealloc(self.raw)
 42 |   self.raw = nil
 43 | 
 44 | proc `=destroy`(self: var Fenster) =
 45 |   discard
 46 |   #if self.raw != nil:
 47 |   #  echo "Fenster window destroyed!" # TODO: remove
 48 |   #  fenster_close(self.raw)
 49 |   #  dealloc(self.raw.buf)
 50 |   #  dealloc(self.raw)
 51 | 
 52 | proc init*(_: type Fenster, title: string, width, height: int, fps: int = 60): Fenster =
 53 |   result = Fenster()
 54 |   
 55 |   result.raw = cast[ptr FensterStruct](alloc0(sizeof(FensterStruct)))
 56 |   result.raw.title = cstring(title)
 57 |   result.raw.width = cint(width)
 58 |   result.raw.height = cint(height)
 59 |   result.raw.buf =
 60 |     cast[ptr UncheckedArray[uint32]](alloc(width * height * sizeof(uint32)))
 61 |   
 62 |   result.targetFps = fps
 63 |   result.lastFrameTime = fenster_time()
 64 |   
 65 |   discard fenster_open(result.raw)
 66 | 
 67 | proc loop*(self: var Fenster): bool =
 68 |   let frameTime = 1000 div self.targetFps
 69 |   let currentTime = fenster_time()
 70 |   let elapsedTime = currentTime - self.lastFrameTime
 71 |   if elapsedTime < frameTime:
 72 |     fenster_sleep((frameTime - elapsedTime).cint)
 73 | 
 74 |   if elapsedTime > 0:
 75 |     self.fps = 1000.0 / elapsedTime.float
 76 |   
 77 |   self.lastFrameTime = fenster_time()
 78 |   result = fenster_loop(self.raw) == 0
 79 | 
 80 | template pixel*(self: Fenster, x, y: int): uint32 = self.raw.buf[y * self.raw.width + x]
 81 | template width*(self: Fenster): int = self.raw.width.int
 82 | template height*(self: Fenster): int = self.raw.height.int
 83 | template keys*(self: Fenster): array[256, cint] = self.raw.keys
 84 | template modkey*(self: Fenster): int = self.raw.modkey.int
 85 | template mouse*(self: Fenster): tuple[pos: tuple[x, y: int], mclick: array[5, cint], mhold: array[3, cint]] =
 86 |   (
 87 |     pos: (x: self.raw.x.int, y: self.raw.y.int),
 88 |     mclick: self.raw.mclick,
 89 |     mhold: self.raw.mhold
 90 |   )
 91 | proc sleep*(self: Fenster, ms: int) = fenster_sleep(ms.cint)
 92 | proc time*(self: Fenster): int64 = fenster_time()
 93 | 
 94 | #Below are functions that are not part of Fenster
 95 | template clear*(self: Fenster) = zeroMem(self.raw.buf, self.raw.width.int * self.raw.height.int * sizeof(uint32))
 96 | proc getFonts*(self: Fenster): seq[string] =
 97 |   let searchPatterns = when defined(linux):
 98 |     @[
 99 |       expandTilde("~/.local/share/fonts/**/*.ttf"),
100 |       expandTilde("~/.fonts/**/*.ttf"),
101 |       "/usr/*/fonts/**/*.ttf",
102 |       "/usr/*/*/fonts/**/*.ttf",
103 |       "/usr/*/*/*/fonts/**/*.ttf",
104 |       "/usr/*/*/*/*/fonts/**/*.ttf"
105 |     ]
106 |   elif defined(macosx):
107 |     @[
108 |       expandTilde("~/Library/Fonts/**/*.ttf"),
109 |       "/Library/Fonts/**/*.ttf",
110 |       "/System/Library/Fonts/**/*.ttf",
111 |       "/Network/Library/Fonts/**/*.ttf"
112 |     ]
113 |   elif defined(windows):
114 |     @[
115 |       getEnv("SYSTEMROOT") & r"\Fonts\*.ttf",
116 |       getEnv("LOCALAPPDATA") & r"\Microsoft\Windows\Fonts\*.ttf"
117 |     ]
118 |   else:
119 |     @[]
120 | 
121 |   result = newSeq[string]()
122 |   for pattern in searchPatterns:
123 |     for entry in walkPattern(pattern):
124 |       result.add(entry)
125 | 


--------------------------------------------------------------------------------
/examples/threaded_mandelbrot.nim:
--------------------------------------------------------------------------------
  1 | import fenstim, math, random, parsecfg, atomics, parseutils, strutils, os
  2 | 
  3 | randomize()
  4 | 
  5 | const CONFIG_FILE = "config.ini"
  6 | const DEFAULT_CONFIG = """
  7 | width=800
  8 | height=600
  9 | targetFps=60
 10 | threadcount=2
 11 | """
 12 | 
 13 | proc createDefaultConfig() =
 14 |   writeFile(CONFIG_FILE, DEFAULT_CONFIG)
 15 | 
 16 | if not fileExists(CONFIG_FILE):
 17 |   createDefaultConfig()
 18 | 
 19 | let dict = loadConfig(CONFIG_FILE)
 20 | 
 21 | proc getConfigValue(key: string, default: int): int =
 22 |   let value = dict.getSectionValue("", key)
 23 |   if value == "": default else: parseInt(value)
 24 | 
 25 | var 
 26 |   WIDTH = getConfigValue("width", 800)
 27 |   HEIGHT = getConfigValue("height", 600)
 28 |   THREAD_COUNT = getConfigValue("threadcount", 2)
 29 |   TARGETFPS = getConfigValue("targetFps", 60)
 30 | 
 31 | type
 32 |   ThreadArg = tuple[startY, endY: int]
 33 | 
 34 | echo "Threads: ", THREAD_COUNT, " ", WIDTH, "x", HEIGHT
 35 | var 
 36 |   app = init(Fenster, "Multi-threaded Edge-focusing Mandelbrot Set", WIDTH, HEIGHT, TARGETFPS)
 37 |   centerX, centerY: float64 = 0.0
 38 |   zoom: float64 = 1.0
 39 |   maxIterations: Atomic[int]
 40 |   zoomSpeed: float64 = 1.02
 41 |   targetX, targetY: float64 = 0.0
 42 | 
 43 | var buffer: seq[uint32]
 44 | buffer.setLen(WIDTH * HEIGHT)
 45 | 
 46 | maxIterations.store(100)
 47 | 
 48 | proc mandelbrot(cx, cy: float64, maxIter: int): int {.inline.} =
 49 |   var 
 50 |     zx, zy, zx2, zy2: float64 = 0.0
 51 |     x = cx
 52 |     y = cy
 53 | 
 54 |   for i in 1..maxIter:
 55 |     if zx2 + zy2 > 4.0: return i
 56 |     zy = 2.0 * zx * zy + y
 57 |     zx = zx2 - zy2 + x
 58 |     zx2 = zx * zx
 59 |     zy2 = zy * zy
 60 | 
 61 |   return maxIter
 62 | 
 63 | proc findInterestingArea(currX, currY, currZoom: float64): tuple[x, y: float64] =
 64 |   const searchRadius = 2.0
 65 |   const samples = 10
 66 |   var bestX: float64 = currX
 67 |   var bestY: float64 = currY
 68 |   var bestScore = 0
 69 | 
 70 |   for _ in 0..<samples:
 71 |     let
 72 |       angle = rand(0.0..2*PI)
 73 |       distance = rand(0.0..searchRadius) / currZoom
 74 |       x = currX + cos(angle) * distance
 75 |       y = currY + sin(angle) * distance
 76 |       iterations = mandelbrot(x, y, maxIterations.load)
 77 |     
 78 |     if iterations > 10 and iterations < maxIterations.load-10:
 79 |       let score = maxIterations.load - abs(iterations - maxIterations.load div 2)
 80 |       if score > bestScore:
 81 |         bestScore = score
 82 |         bestX = x
 83 |         bestY = y
 84 | 
 85 |   if bestScore == 0:
 86 |     let angle = rand(0.0..2*PI)
 87 |     bestX = currX + cos(angle) * (0.1 / currZoom)
 88 |     bestY = currY + sin(angle) * (0.1 / currZoom)
 89 | 
 90 |   return (bestX, bestY)
 91 | 
 92 | proc drawSection(arg: ThreadArg) {.thread.} =
 93 |   let (startY, endY) = arg
 94 |   let maxIter = maxIterations.load
 95 | 
 96 |   {.cast(gcsafe).}:
 97 |     for py in startY..<endY:
 98 |       for px in 0..<WIDTH:
 99 |         let 
100 |           x = (px.float64 - WIDTH.float64/2) / (0.25*zoom*WIDTH.float64) + centerX
101 |           y = (py.float64 - HEIGHT.float64/2) / (0.25*zoom*HEIGHT.float64) + centerY
102 |           c = mandelbrot(x, y, maxIter)
103 |           r = uint8((sin(c.float64 * 0.1) + 1) * 127)
104 |           g = uint8((sin(c.float64 * 0.13 + 1) + 1) * 127)
105 |           b = uint8((sin(c.float64 * 0.17 + 2) + 1) * 127)
106 | 
107 |         buffer[py * WIDTH + px] = (r.uint32 shl 16) or (g.uint32 shl 8) or b.uint32
108 | 
109 | proc draw() =
110 |   var threads: seq[Thread[ThreadArg]]
111 |   
112 |   threads.setLen(THREAD_COUNT)
113 |   let sectionHeight = HEIGHT div THREAD_COUNT
114 | 
115 |   for i in 0..<THREAD_COUNT:
116 |     let startY = i * sectionHeight
117 |     let endY = if i == THREAD_COUNT - 1: HEIGHT else: (i + 1) * sectionHeight
118 |     createThread(threads[i], drawSection, (startY: startY, endY: endY))
119 | 
120 |   joinThreads(threads)
121 | 
122 |   for y in 0..<HEIGHT:
123 |     for x in 0..<WIDTH:
124 |       app.pixel(x, y) = buffer[y * WIDTH + x]
125 | 
126 | var frameCount: uint32 = 0
127 | 
128 | while app.loop and app.keys[27] == 0:
129 |   draw()
130 | 
131 |   zoom *= zoomSpeed
132 |   centerX += (targetX - centerX) * 0.05
133 |   centerY += (targetY - centerY) * 0.05
134 | 
135 |   frameCount += 1
136 |   if frameCount mod 30 == 0:
137 |     (targetX, targetY) = findInterestingArea(centerX, centerY, zoom)
138 |     echo "Frame: ", frameCount, " FPS: ", app.fps.int
139 | 
140 |   maxIterations.store(int(100.0 * log10(zoom + 1)))
141 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Fenstim
  2 | Fenstim is a Nim wrapper for [Fenster](https://github.com/zserge/fenster), the most minimal cross-platform GUI with 2D canvas library. It provides a simple and efficient way to create graphical applications in Nim.
  3 | 
  4 | # Implementation status
  5 | - [x] Minimal 24-bit RGB framebuffer.
  6 | - [x] Application lifecycle and system events are all handled automatically.
  7 | - [x] Simple polling API without a need for callbacks or multithreading (like Arduino/Processing).
  8 | - [x] Cross-platform keyboard events (keycodes).
  9 | - [x] Cross-platform mouse events (X/Y + mouse click).
 10 | - [x] Cross-platform timers to have a stable FPS rate. (builtin)
 11 | - [x] Cross-platform audio playback (WinMM, CoreAudio, ALSA).
 12 | 
 13 | # Credits
 14 | Project done in collaboration with @ElegantBeef and @morturo at https://forum.nim-lang.org/t/12504
 15 | 
 16 | # Examples
 17 | Basic usage
 18 | ```nim
 19 | import fenstim, colors
 20 | 
 21 | var app = init(Fenster, "My Window", 800, 600, 60)
 22 | 
 23 | if app.loop:
 24 |   echo "Window target FPS: ", app.targetFps, ", Resolution: ", app.width, "x", app.height
 25 | 
 26 | while app.loop:
 27 |   # Set pixel color
 28 |   app.pixel(400, 300) = 16711680  # Decimal red
 29 |   app.pixel(420, 300) = 0x0000FF  # Hex blue
 30 |   pixel(app, 410, 300) = 0x00ff00 # Hex green
 31 | 
 32 |   # With colors module
 33 |   app.pixel(390, 300) = rgb(255, 0, 0).uint32        # Red
 34 |   app.pixel(380, 300) = parseColor("#00FF00").uint32 # Green
 35 |   app.pixel(370, 300) = colAliceBlue.uint32          # Alice Blue
 36 |   app.pixel(360, 300) = parseColor("silver").uint32  # Silver
 37 | 
 38 |   # Get pixel color
 39 |   let color = app.pixel(420, 300) # Decimal
 40 | 
 41 |   # Check key press if A key is pressed
 42 |   if app.keys[ord('A')] == 1:
 43 |     echo "A key is pressed"
 44 | 
 45 |   # Check if scape key is pressed
 46 |   if keys(app)[27] == 1:
 47 |     app.close
 48 |     break
 49 | 
 50 |   # Get mouse position and click state
 51 |   if app.mouse.mclick[0] == 1:
 52 |     echo "Clicked at: ", app.mouse.pos.x, "x", app.mouse.pos.y
 53 | 
 54 |   # Adjust FPS
 55 |   app.targetFps = 30
 56 | ```
 57 | 
 58 | Opens a 60fps 800x600 window, draws a red square and exits when pressing the Escape key:
 59 | 
 60 | ```nim
 61 | # examples/red_square.nim
 62 | import fenstim
 63 | 
 64 | var app = init(Fenster, "Red square with fenstim", 800, 600, 60)
 65 | 
 66 | while app.loop and app.keys[27] == 0:
 67 |   for x in 350 .. 450:
 68 |     for y in 250 .. 350:
 69 |       app.pixel(x, y) = 0xFF0000
 70 | ```
 71 | 
 72 | # API usage
 73 | ### Initialization
 74 | ```nim
 75 | init*(_: type Fenster, title: string, width, height: int, fps: int = 60): Fenster
 76 | ```  
 77 | Creates a new Fenster window with the specified title, dimensions, and target FPS.
 78 | 
 79 | ### Main Loop
 80 | ```nim
 81 | loop*(self: var Fenster): bool
 82 | ```
 83 | Handles events and updates the display. Returns false when the window should close.
 84 | 
 85 | ### Pixel Manipulation
 86 | ```nim
 87 | pixel*(self: Fenster, x, y: int): uint32
 88 | ```
 89 | Get or set a uint32 pixel color at (x, y).
 90 | 
 91 | ### Window Properties
 92 | ```nim
 93 | width*(self: Fenster): int
 94 | height*(self: Fenster): int
 95 | targetFps*(self: Fenster): int
 96 | close*(self: var Fenster)
 97 | clear*(self: Fenster)
 98 | ```
 99 | 
100 | ### Input Handling
101 | ```nim
102 | keys*(self: Fenster): array[256, cint]
103 | mouse*(self: Fenster): tuple[pos: tuple[x, y: int], mclick: array[5, cint], mhold: array[3, cint]]
104 | modkey*(self: Fenster): int
105 | ```
106 | keys = Array of key states. Index corresponds to ASCII value (0-255), but arrows are 17..20.  
107 | mouse = Get mouse position (x, y), clicked (left, right, middle, scroll up, scroll down) and holding buttons (left, right, middle)  
108 | modkey = 4 bits mask, ctrl=1, shift=2, alt=4, meta=8
109 | 
110 | # Examples
111 | ### Galery
112 | ![lca1](https://github.com/user-attachments/assets/4da9fa7f-e201-4f18-a262-d53fcbdb0380)  
113 | ![lca2](https://github.com/user-attachments/assets/9a8654af-e5fc-4b1e-9c3f-2eeaf2bf2016)  
114 | ![lca3](https://github.com/user-attachments/assets/c2fe1c8f-b138-491f-be7b-0baa1f553259)  
115 | ![lca5](https://github.com/user-attachments/assets/73e1280f-a988-4190-bf6e-1f94fee1d8d9)  
116 | ![lca4](https://github.com/user-attachments/assets/93b30453-de4e-4952-8729-87f149b02a13)  
117 | [interactive_julia_set.nim](examples/interactive_julia_set.nim)  
118 | ![ezgif-2-1a773886a7](https://github.com/user-attachments/assets/95116b60-cdf0-4308-9f90-593e97bd60d0)  
119 | [mandelbrot.nim](examples/mandelbrot.nim)  
120 | [threaded_mandelbrot.nim](examples/threaded_mandelbrot.nim)  
121 | 


--------------------------------------------------------------------------------