feat: Common Lisp notepat — keyboard instrument boots on bare metal

Port notepat core from JS to Common Lisp for AC Native OS:
- Full QWERTY keyboard → chromatic note mapping (2.5 octaves)
- 5 wave types (sine/triangle/sawtooth/square/noise) with Tab cycling
- 32-voice polyphonic ALSA synth with stereo panning
- ALSA mixer auto-unmute + volume max (fixes silent audio)
- Per-note chromatic rainbow colors with trail effects
- Background color lerps to match active notes
- 6x10 bitmap font rendering for status bar
- Optimized fb-copy-scaled using memcpy (was per-pixel loops)
- Pixel scale targets ~200px wide (bigger pixels)
- Octave control (1-9 / arrows), ESC triple-press quit
- Progress log at fedac/native/cl/PROGRESS.md

Co-Authored-By: Claude Opus 4.6 (1M context) <[e-mail]>

fedac/native/cl/PROGRESS.md

···
+# AC Native OS — Common Lisp Edition Progress
+
+## Overview
+
+A bare-metal Common Lisp OS runtime for AC Native, using SBCL + CFFI. Boots directly to notepat (musical keyboard instrument) on real ThinkPad hardware via UEFI.
+
+## Architecture
+
+- **Runtime**: SBCL 2.6.2 compiled to standalone binary (~12MB)
+- **Graphics**: DRM/KMS framebuffer with pixel scaling (targets ~200px wide)
+- **Audio**: ALSA PCM with 32-voice polyphonic synth (48kHz stereo S16LE)
+- **Input**: evdev keyboard polling (full QWERTY)
+- **Build**: Docker reproducible build (Fedora 43 + GCC 15 + Linux 6.19.9)
+- **Boot**: UEFI → Linux kernel with embedded initramfs → SBCL binary as /init child
+
+## What Works (2026-03-22)
+
+### Core Runtime
+- [x] DRM display init (card0/card1/card2 probe + fbdev fallback)
+- [x] Double-buffered dumb buffers with page flip
+- [x] Pixel scaling with optimized memcpy-based fb-copy-scaled
+- [x] 60fps frame sync via clock_nanosleep
+- [x] evdev input polling (keyboard)
+- [x] ALSA audio output with mixer unmute + volume max
+- [x] 5 oscillator types: sine, square, triangle, sawtooth, noise
+- [x] Polyphonic synth (32 voices, per-voice pan/attack/decay/duration)
+- [x] Audio thread with lock-based voice management
+
+### Graphics
+- [x] Immediate-mode primitives: wipe, ink, plot, line, box, circle
+- [x] Alpha blending (per-pixel ARGB32)
+- [x] 6x10 bitmap font rendering with scaling
+- [x] Color system (make-color, pack-argb32, blend)
+
+### Notepat Instrument
+- [x] QWERTY keyboard → chromatic note mapping (2.5 octaves per layout)
+- [x] Key down → synth voice, key up → kill voice
+- [x] Per-note chromatic rainbow colors
+- [x] Background color lerps to average of active notes
+- [x] Trail effect: fading colored bars per note+octave on release
+- [x] Active note indicators (bright full-width bars)
+- [x] Octave control (1-9 keys, arrow up/down)
+- [x] Wave type cycling (Tab: sine → triangle → sawtooth → square → noise)
+- [x] Confirmation blip sound on wave switch
+- [x] Stereo panning (lower notes left, higher notes right)
+- [x] Status bar: wave type, octave, FPS counter
+- [x] ESC triple-press to quit
+- [x] Power button to quit
+
+### Build System
+- [x] Docker reproducible build (Dockerfile.builder)
+- [x] AC_BUILD_LISP=1 flag swaps CL binary into initramfs
+- [x] Oven OTA pipeline compatible
+- [x] USB flash via privileged Docker container
+
+## What's Next
+
+### Short Term
+- [ ] Audio: sample recording/playback (microphone capture + sample bank)
+- [ ] Audio: echo/room effect
+- [ ] Audio: pitch shift (trackpad or slider)
+- [ ] Input: touch/trackpad support
+- [ ] Display: boot animation / splash screen
+- [ ] System: USB log writing for debug
+- [ ] System: config.json reading (handle, credentials)
+
+### Medium Term
+- [ ] WiFi management (wpa_supplicant integration)
+- [ ] OTA self-update
+- [ ] Metronome (clock-synced)
+- [ ] Text-to-speech (flite integration)
+- [ ] Multiple pieces with piece switching (prompt → notepat)
+- [ ] Touch grid UI for note pads
+
+### Long Term
+- [ ] KidLisp evaluator in CL (replace QuickJS)
+- [ ] Network/WebSocket for multiplayer
+- [ ] Full piece API surface (matching JS disk.mjs)
+
+## File Map
+
+| File | Purpose |
+|------|---------|
+| `main.lisp` | Entry point, notepat instrument loop |
+| `packages.lisp` | All package/export definitions |
+| `drm-display.lisp` | DRM/KMS init, dumb buffers, page flip, present |
+| `drm-constants.lisp` | DRM ioctl numbers and struct defs |
+| `framebuffer.lisp` | Pixel buffer alloc, clear, plot, blend, scaled copy |
+| `graph.lisp` | Immediate-mode 2D: wipe, ink, plot, line, box, circle |
+| `color.lisp` | ARGB32 color struct, packing, alpha blend |
+| `font-data.lisp` | 6x10 BDF bitmap font (95 ASCII chars) |
+| `font.lisp` | Font rendering and measurement |
+| `audio.lisp` | ALSA init, mixer unmute, voice management, audio thread |
+| `audio-synth.lisp` | Oscillators (sine/square/tri/saw/noise), voice struct |
+| `alsa-bindings.lisp` | CFFI bindings for libasound |
+| `input.lisp` | evdev device scanning, event polling |
+| `input-keycodes.lisp` | Linux keycode constants (full QWERTY) |
+| `syscalls.lisp` | CFFI wrappers for Linux syscalls |
+| `util.lisp` | Logging, monotonic clock, frame sync |
+| `config.lisp` | USB config.json reader |
+| `ac-native.asd` | ASDF system definition |
+| `build.lisp` | SBCL save-lisp-and-die build script |
+
+## Hardware Tested
+
+- ThinkPad X1 Nano Gen 2 (Intel i915)
+- ThinkPad Yoga 11e Gen 5 (Intel i915)

fedac/native/cl/audio.lisp

···
   (next-id 1 :type fixnum)
   (lock (bordeaux-threads:make-lock "audio")))
 
+(defun unmute-all-mixers (card-name)
+  "Open the ALSA mixer for CARD-NAME, unmute all playback switches, set volumes to max."
+  (ac-native.util:ac-log "[audio] unmuting mixer: ~A~%" card-name)
+  (cffi:with-foreign-object (mixer-ptr :pointer)
+    (when (zerop (cffi:foreign-funcall "snd_mixer_open"
+                   :pointer mixer-ptr :int 0 :int))
+      (let ((mixer (cffi:mem-ref mixer-ptr :pointer)))
+        (cffi:foreign-funcall "snd_mixer_attach"
+          :pointer mixer :string card-name :int)
+        (cffi:foreign-funcall "snd_mixer_selem_register"
+          :pointer mixer :pointer (cffi:null-pointer) :pointer (cffi:null-pointer) :int)
+        (cffi:foreign-funcall "snd_mixer_load" :pointer mixer :int)
+        ;; Iterate all elements
+        (loop for elem = (cffi:foreign-funcall "snd_mixer_first_elem"
+                           :pointer mixer :pointer)
+                then (cffi:foreign-funcall "snd_mixer_elem_next"
+                       :pointer elem :pointer)
+              until (cffi:null-pointer-p elem) do
+          (let ((name (cffi:foreign-funcall "snd_mixer_selem_get_name"
+                        :pointer elem :string)))
+            (when (not (zerop (cffi:foreign-funcall "snd_mixer_selem_is_active"
+                                :pointer elem :int)))
+              ;; Unmute playback switch
+              (when (not (zerop (cffi:foreign-funcall "snd_mixer_selem_has_playback_switch"
+                                  :pointer elem :int)))
+                (cffi:foreign-funcall "snd_mixer_selem_set_playback_switch_all"
+                  :pointer elem :int 1 :int)
+                (ac-native.util:ac-log "[audio] unmuted: ~A~%" name))
+              ;; Set volume to max
+              (when (not (zerop (cffi:foreign-funcall "snd_mixer_selem_has_playback_volume"
+                                  :pointer elem :int)))
+                (cffi:with-foreign-objects ((minv :long) (maxv :long))
+                  (cffi:foreign-funcall "snd_mixer_selem_get_playback_volume_range"
+                    :pointer elem :pointer minv :pointer maxv :int)
+                  (let ((mx (cffi:mem-ref maxv :long)))
+                    (cffi:foreign-funcall "snd_mixer_selem_set_playback_volume_all"
+                      :pointer elem :long mx :int)
+                    (ac-native.util:ac-log "[audio] volume ~A: ~D~%" name mx)))))))
+        (cffi:foreign-funcall "snd_mixer_close" :pointer mixer :int)))))
+
 (defun audio-init ()
   "Initialize ALSA audio output and start the mixing thread."
-  (multiple-value-bind (pcm err) (ac-native.alsa:pcm-open "default")
+  ;; Try multiple devices with retries (HDA codec may not be probed yet)
+  (let ((devices '("hw:0,0" "hw:1,0" "hw:0,1" "hw:1,1"
+                   "plughw:0,0" "plughw:1,0" "default"))
+        (pcm nil)
+        (card-idx 0))
+    (loop for attempt from 0 below 5
+          until pcm do
+      (when (> attempt 0)
+        (ac-native.util:ac-log "[audio] retry ~D/4 — waiting 2s...~%" attempt)
+        (sleep 2))
+      (dolist (dev devices)
+        (multiple-value-bind (handle err) (ac-native.alsa:pcm-open dev)
+          (when handle
+            (ac-native.util:ac-log "[audio] opened: ~A (attempt ~D)~%" dev attempt)
+            (setf pcm handle)
+            ;; Extract card index from device name
+            (let ((pos (position #\: dev)))
+              (when pos
+                (let ((ch (char dev (1+ pos))))
+                  (when (digit-char-p ch)
+                    (setf card-idx (- (char-code ch) (char-code #\0)))))))
+            (return))
+          (when (= attempt 0)
+            (ac-native.util:ac-log "[audio] ~A: ~A~%" dev
+                                    (ac-native.alsa:snd-strerror err))))))
+
     (unless pcm
-      (ac-native.util:ac-log "[audio] failed to open: ~A~%"
-                              (ac-native.alsa:snd-strerror err))
-      ;; Try hw:0,0
-      (multiple-value-setq (pcm err) (ac-native.alsa:pcm-open "hw:0,0"))
-      (unless pcm
-        (ac-native.util:ac-log "[audio] hw:0,0 also failed~%")
-        (return-from audio-init nil)))
+      (ac-native.util:ac-log "[audio] no ALSA device found~%")
+      (return-from audio-init nil))
 
     ;; Set params: S16_LE, stereo, 48kHz, 50ms latency
     (let ((ret (ac-native.alsa:pcm-set-params
···
                                 (ac-native.alsa:snd-strerror ret))
         (ac-native.alsa:pcm-close pcm)
         (return-from audio-init nil)))
+
+    ;; Unmute all mixer controls and set volumes to max
+    (handler-case
+        (unmute-all-mixers (format nil "hw:~D" card-idx))
+      (error (e)
+        (ac-native.util:ac-log "[audio] mixer error: ~A~%" e)))
 
     (let ((audio (make-ac-audio :pcm pcm :running t)))
       ;; Init voice slots

fedac/native/cl/font-data.lisp

···
-;;; Font bitmap data — placeholder, will be generated from C headers
+;;; Font bitmap data — 6x10 BDF font (Misc-Fixed-Medium-R-Normal--10)
+;;; 95 printable ASCII chars (32-126), each 10 rows, 6px wide (MSB-first in byte)
 
 (in-package :ac-native.font)
 
-;; 8x8 font — 95 printable ASCII characters (space through ~)
-;; Each character is 8 bytes (8 rows of 8 pixels)
-;; TODO: port from fedac/native/src/font-8x8.h
-(defvar *font-8x8* (make-array (* 95 8) :element-type '(unsigned-byte 8) :initial-element 0))
+(defconstant +font-w+ 6)
+(defconstant +font-h+ 10)
+
+(defvar *font-6x10*
+  (make-array '(95 10)
+    :element-type '(unsigned-byte 8)
+    :initial-contents
+    '((0 0 0 0 0 0 0 0 0 0)          ; SPC (32)
+      (0 32 32 32 32 32 0 32 0 0)     ; ! (33)
+      (0 80 80 80 0 0 0 0 0 0)        ; " (34)
+      (0 80 80 248 80 248 80 80 0 0)  ; # (35)
+      (0 32 112 160 112 40 112 32 0 0) ; $ (36)
+      (0 72 168 80 32 80 168 144 0 0) ; % (37)
+      (0 64 160 160 64 168 144 104 0 0) ; & (38)
+      (0 32 32 32 0 0 0 0 0 0)        ; ' (39)
+      (0 16 32 64 64 64 32 16 0 0)    ; ( (40)
+      (0 64 32 16 16 16 32 64 0 0)    ; ) (41)
+      (0 0 136 80 248 80 136 0 0 0)   ; * (42)
+      (0 0 32 32 248 32 32 0 0 0)     ; + (43)
+      (0 0 0 0 0 0 48 32 64 0)        ; , (44)
+      (0 0 0 0 248 0 0 0 0 0)         ; - (45)
+      (0 0 0 0 0 0 32 112 32 0)       ; . (46)
+      (0 8 8 16 32 64 128 128 0 0)    ; / (47)
+      (0 32 80 136 136 136 80 32 0 0) ; 0 (48)
+      (0 32 96 160 32 32 32 248 0 0)  ; 1 (49)
+      (0 112 136 8 48 64 128 248 0 0) ; 2 (50)
+      (0 248 8 16 48 8 136 112 0 0)   ; 3 (51)
+      (0 16 48 80 144 248 16 16 0 0)  ; 4 (52)
+      (0 248 128 176 200 8 136 112 0 0) ; 5 (53)
+      (0 48 64 128 176 200 136 112 0 0) ; 6 (54)
+      (0 248 8 16 16 32 64 64 0 0)    ; 7 (55)
+      (0 112 136 136 112 136 136 112 0 0) ; 8 (56)
+      (0 112 136 152 104 8 16 96 0 0) ; 9 (57)
+      (0 0 32 112 32 0 32 112 32 0)   ; : (58)
+      (0 0 32 112 32 0 48 32 64 0)    ;   (59)
+      (0 8 16 32 64 32 16 8 0 0)      ; < (60)
+      (0 0 0 248 0 248 0 0 0 0)       ; = (61)
+      (0 64 32 16 8 16 32 64 0 0)     ; > (62)
+      (0 112 136 16 32 32 0 32 0 0)   ; ? (63)
+      (0 112 136 152 168 176 128 112 0 0) ; @ (64)
+      (0 32 80 136 136 248 136 136 0 0) ; A (65)
+      (0 240 72 72 112 72 72 240 0 0) ; B (66)
+      (0 112 136 128 128 128 136 112 0 0) ; C (67)
+      (0 240 72 72 72 72 72 240 0 0)  ; D (68)
+      (0 248 128 128 240 128 128 248 0 0) ; E (69)
+      (0 248 128 128 240 128 128 128 0 0) ; F (70)
+      (0 112 136 128 128 152 136 112 0 0) ; G (71)
+      (0 136 136 136 248 136 136 136 0 0) ; H (72)
+      (0 112 32 32 32 32 32 112 0 0)  ; I (73)
+      (0 56 16 16 16 16 144 96 0 0)   ; J (74)
+      (0 136 144 160 192 160 144 136 0 0) ; K (75)
+      (0 128 128 128 128 128 128 248 0 0) ; L (76)
+      (0 136 136 216 168 136 136 136 0 0) ; M (77)
+      (0 136 136 200 168 152 136 136 0 0) ; N (78)
+      (0 112 136 136 136 136 136 112 0 0) ; O (79)
+      (0 240 136 136 240 128 128 128 0 0) ; P (80)
+      (0 112 136 136 136 136 168 112 8 0) ; Q (81)
+      (0 240 136 136 240 160 144 136 0 0) ; R (82)
+      (0 112 136 128 112 8 136 112 0 0) ; S (83)
+      (0 248 32 32 32 32 32 32 0 0)   ; T (84)
+      (0 136 136 136 136 136 136 112 0 0) ; U (85)
+      (0 136 136 136 80 80 80 32 0 0) ; V (86)
+      (0 136 136 136 168 168 216 136 0 0) ; W (87)
+      (0 136 136 80 32 80 136 136 0 0) ; X (88)
+      (0 136 136 80 32 32 32 32 0 0)  ; Y (89)
+      (0 248 8 16 32 64 128 248 0 0)  ; Z (90)
+      (0 112 64 64 64 64 64 112 0 0)  ; [ (91)
+      (0 128 128 64 32 16 8 8 0 0)    ; \ (92)
+      (0 112 16 16 16 16 16 112 0 0)  ; ] (93)
+      (0 32 80 136 0 0 0 0 0 0)       ; ^ (94)
+      (0 0 0 0 0 0 0 0 248 0)         ; _ (95)
+      (32 16 0 0 0 0 0 0 0 0)         ; ` (96)
+      (0 0 0 112 8 120 136 120 0 0)   ; a (97)
+      (0 128 128 176 200 136 200 176 0 0) ; b (98)
+      (0 0 0 112 136 128 136 112 0 0) ; c (99)
+      (0 8 8 104 152 136 152 104 0 0) ; d (100)
+      (0 0 0 112 136 248 128 112 0 0) ; e (101)
+      (0 48 72 64 240 64 64 64 0 0)   ; f (102)
+      (0 0 0 120 136 136 120 8 136 112) ; g (103)
+      (0 128 128 176 200 136 136 136 0 0) ; h (104)
+      (0 32 0 96 32 32 32 112 0 0)    ; i (105)
+      (0 8 0 24 8 8 8 72 72 48)       ; j (106)
+      (0 128 128 136 144 224 144 136 0 0) ; k (107)
+      (0 96 32 32 32 32 32 112 0 0)   ; l (108)
+      (0 0 0 208 168 168 168 136 0 0) ; m (109)
+      (0 0 0 176 200 136 136 136 0 0) ; n (110)
+      (0 0 0 112 136 136 136 112 0 0) ; o (111)
+      (0 0 0 176 200 136 200 176 128 128) ; p (112)
+      (0 0 0 104 152 136 152 104 8 8) ; q (113)
+      (0 0 0 176 200 128 128 128 0 0) ; r (114)
+      (0 0 0 112 128 112 8 240 0 0)   ; s (115)
+      (0 64 64 240 64 64 72 48 0 0)   ; t (116)
+      (0 0 0 136 136 136 152 104 0 0) ; u (117)
+      (0 0 0 136 136 80 80 32 0 0)    ; v (118)
+      (0 0 0 136 136 168 168 80 0 0)  ; w (119)
+      (0 0 0 136 80 32 80 136 0 0)    ; x (120)
+      (0 0 0 136 136 152 104 8 136 112) ; y (121)
+      (0 0 0 248 16 32 64 248 0 0)    ; z (122)
+      (0 24 32 16 96 16 32 24 0 0)    ; { (123)
+      (0 32 32 32 32 32 32 32 0 0)    ; | (124)
+      (0 96 16 32 24 32 16 96 0 0)    ; } (125)
+      (0 72 168 144 0 0 0 0 0 0)      ; ~ (126)
+      )))

fedac/native/cl/font.lisp

···
-;;; Font rendering — bitmap font draw/measure
+;;; Font rendering — 6x10 bitmap font
 
 (in-package :ac-native.font)
 
 (defun font-init ()
   "Load font data. Called once at startup."
-  ;; TODO: populate *font-8x8* from header data
+  ;; Data is statically defined in font-data.lisp
   )
 
 (defun font-draw (graph text x y &key (size 1))
-  "Draw TEXT at (X, Y) using the 8x8 bitmap font."
-  (declare (ignore graph text x y size))
-  ;; TODO: implement
-  )
+  "Draw TEXT at (X, Y) using the 6x10 bitmap font, scaled by SIZE."
+  (declare (type fixnum x y size))
+  (let ((cx x))
+    (loop for ch across text do
+      (let ((idx (- (char-code ch) 32)))
+        (when (and (>= idx 0) (< idx 95))
+          (dotimes (row +font-h+)
+            (let ((byte (aref *font-6x10* idx row)))
+              (dotimes (col +font-w+)
+                (when (logbitp (- 7 col) byte)
+                  (if (= size 1)
+                      (graph-plot graph (+ cx col) (+ y row))
+                      ;; Scaled: draw size x size block per pixel
+                      (dotimes (dy size)
+                        (dotimes (dx size)
+                          (graph-plot graph
+                                     (+ cx (* col size) dx)
+                                     (+ y (* row size) dy)))))))))))
+      (incf cx (* +font-w+ size)))))
 
 (defun font-measure (text &key (size 1))
-  "Return the pixel width of TEXT in the 8x8 font."
-  (declare (ignore size))
-  (* (length text) 8))
-
-(defun font-draw-matrix (graph text x y size)
-  "Draw TEXT using the MatrixChunky8 font."
-  (declare (ignore graph text x y size))
-  ;; TODO: implement
-  )
-
-(defun font-measure-matrix (text size)
-  "Return pixel width of TEXT in MatrixChunky8."
-  (declare (ignore size))
-  (* (length text) 10))
+  "Return the pixel width of TEXT in the 6x10 font."
+  (* (length text) +font-w+ size))

fedac/native/cl/framebuffer.lisp

···
 
 (defun fb-copy-scaled (src dst-ptr dst-w dst-h dst-stride scale)
   "Copy SRC framebuffer to a foreign memory region at DST-PTR, scaling up by SCALE.
-   Used by DRM present to blit the small render buffer to the display."
+   Used by DRM present to blit the small render buffer to the display.
+   Optimized: expand each source row into a temp row, then memcpy to fill scale rows."
   (declare (optimize (speed 3) (safety 0))
            (type fixnum dst-w dst-h dst-stride scale)
            (type framebuffer src))
-  (let ((sw (framebuffer-width src))
-        (sh (framebuffer-height src))
-        (sp (framebuffer-pixels src)))
-    (dotimes (sy sh)
-      (dotimes (sx sw)
-        (let ((pixel (cffi:mem-aref sp :uint32 (+ sx (* sy sw)))))
-          ;; Replicate pixel into scale x scale block
-          (dotimes (dy scale)
-            (let ((oy (* (+ (* (+ (* sy scale) dy) 1) 0) 1))) ; row offset placeholder
-              (declare (ignore oy))
-              (let ((row (+ (* sy scale) dy)))
-                (when (< row dst-h)
-                  (dotimes (dx scale)
-                    (let ((col (+ (* sx scale) dx)))
-                      (when (< col dst-w)
-                        (setf (cffi:mem-aref dst-ptr :uint32
-                                             (+ col (* row dst-stride)))
-                              pixel)))))))))))))
+  (let* ((sw (framebuffer-width src))
+         (sh (framebuffer-height src))
+         (sp (framebuffer-pixels src))
+         (row-bytes (* dst-stride 4)))  ; bytes per destination row
+    ;; For scale=1, use fast memcpy path
+    (if (= scale 1)
+        (let ((copy-w (min sw dst-w)))
+          (dotimes (y (min sh dst-h))
+            (cffi:foreign-funcall "memcpy"
+              :pointer (cffi:inc-pointer dst-ptr (* y row-bytes))
+              :pointer (cffi:inc-pointer sp (* y sw 4))
+              :unsigned-long (* copy-w 4)
+              :pointer)))
+        ;; General case: expand each source row, then replicate
+        (let* ((expanded-w (min (* sw scale) dst-w))
+               (expanded-bytes (* expanded-w 4)))
+          ;; Temp buffer for one expanded row
+          (cffi:with-foreign-object (tmp :uint32 expanded-w)
+            (dotimes (sy sh)
+              (let ((dst-y0 (* sy scale)))
+                (when (>= dst-y0 dst-h) (return))
+                ;; Expand source row: replicate each pixel `scale` times
+                (let ((src-row-offset (* sy sw)))
+                  (dotimes (sx sw)
+                    (let ((pixel (cffi:mem-aref sp :uint32 (+ src-row-offset sx)))
+                          (dx0 (* sx scale)))
+                      (when (>= dx0 dst-w) (return))
+                      (dotimes (dx scale)
+                        (let ((col (+ dx0 dx)))
+                          (when (>= col expanded-w) (return))
+                          (setf (cffi:mem-aref tmp :uint32 col) pixel))))))
+                ;; Copy expanded row to each of the `scale` destination rows
+                (dotimes (dy scale)
+                  (let ((row (+ dst-y0 dy)))
+                    (when (>= row dst-h) (return))
+                    (cffi:foreign-funcall "memcpy"
+                      :pointer (cffi:inc-pointer dst-ptr (* row row-bytes))
+                      :pointer tmp
+                      :unsigned-long expanded-bytes
+                      :pointer))))))))))

fedac/native/cl/input-keycodes.lisp

···
-;;; Linux input keycodes
+;;; Linux input keycodes — full QWERTY for notepat
 
 (in-package :ac-native.input)
 
+;;; Event types
+(defconstant +ev-key+ 1)
+(defconstant +ev-rel+ 2)
+(defconstant +ev-abs+ 3)
+
+;;; Special keys
 (defconstant +key-esc+ 1)
-(defconstant +key-1+ 2)
 (defconstant +key-backspace+ 14)
 (defconstant +key-tab+ 15)
 (defconstant +key-enter+ 28)
 (defconstant +key-leftctrl+ 29)
-(defconstant +key-a+ 30)
 (defconstant +key-space+ 57)
 (defconstant +key-f1+ 59)
 (defconstant +key-up+ 103)
···
 (defconstant +key-home+ 102)
 (defconstant +key-end+ 107)
 (defconstant +key-power+ 116)
+(defconstant +key-minus+ 12)
+(defconstant +key-equal+ 13)
 
-;;; Event types
-(defconstant +ev-key+ 1)
-(defconstant +ev-rel+ 2)
-(defconstant +ev-abs+ 3)
+;;; Number row (for octave selection)
+(defconstant +key-1+ 2)
+(defconstant +key-2+ 3)
+(defconstant +key-3+ 4)
+(defconstant +key-4+ 5)
+(defconstant +key-5+ 6)
+(defconstant +key-6+ 7)
+(defconstant +key-7+ 8)
+(defconstant +key-8+ 9)
+(defconstant +key-9+ 10)
+(defconstant +key-0+ 11)
+
+;;; QWERTY top row
+(defconstant +key-q+ 16)
+(defconstant +key-w+ 17)
+(defconstant +key-e+ 18)
+(defconstant +key-r+ 19)
+(defconstant +key-t+ 20)
+(defconstant +key-y+ 21)
+(defconstant +key-u+ 22)
+(defconstant +key-i+ 23)
+(defconstant +key-o+ 24)
+(defconstant +key-p+ 25)
+(defconstant +key-leftbrace+ 26)
+(defconstant +key-rightbrace+ 27)
+
+;;; QWERTY home row
+(defconstant +key-a+ 30)
+(defconstant +key-s+ 31)
+(defconstant +key-d+ 32)
+(defconstant +key-f+ 33)
+(defconstant +key-g+ 34)
+(defconstant +key-h+ 35)
+(defconstant +key-j+ 36)
+(defconstant +key-k+ 37)
+(defconstant +key-l+ 38)
+(defconstant +key-semicolon+ 39)
+(defconstant +key-apostrophe+ 40)
+
+;;; QWERTY bottom row
+(defconstant +key-z+ 44)
+(defconstant +key-x+ 45)
+(defconstant +key-c+ 46)
+(defconstant +key-v+ 47)
+(defconstant +key-b+ 48)
+(defconstant +key-n+ 49)
+(defconstant +key-m+ 50)
 
 ;;; struct input_event (24 bytes on x86-64)
 (cffi:defcstruct input-event

fedac/native/cl/main.lisp

···
-;;; Main entry point — AC Native OS (Common Lisp edition)
-;;; First boot: just show a colored screen to prove DRM works
+;;; Notepat — AC Native OS musical keyboard instrument (Common Lisp)
+;;; Port of fedac/native/pieces/notepat.mjs core functionality
 
 (in-package :ac-native)
 
 (defvar *running* t "Main loop flag.")
+
+;;; ── Pixel scale ──
 
 (defun compute-pixel-scale (display-w)
-  "Compute pixel scale targeting ~300px wide."
-  (let ((target (max 1 (min 16 (floor display-w 300)))))
+  "Compute pixel scale targeting ~200px wide (bigger pixels)."
+  (let ((target (max 1 (min 16 (floor display-w 200)))))
     (loop for delta from 0 to 3 do
       (let ((s (+ target delta)))
         (when (and (>= s 1) (<= s 16) (zerop (mod display-w s)))
···
           (return-from compute-pixel-scale s))))
     target))
 
+;;; ── Music theory ──
+
+(defvar *chromatic* #("c" "c#" "d" "d#" "e" "f" "f#" "g" "g#" "a" "a#" "b"))
+
+(defun note-to-freq (note-name octave)
+  "Convert note name and octave to frequency in Hz.
+   A4 = 440Hz. Uses equal temperament."
+  (let ((idx (position note-name *chromatic* :test #'string=)))
+    (if idx
+        (* 440.0d0 (expt 2.0d0 (+ (- octave 4) (/ (- idx 9) 12.0d0))))
+        440.0d0)))
+
+;;; ── Note colors (chromatic rainbow) ──
+
+(defvar *note-colors*
+  '(("c"  255  30  30)    ; red
+    ("c#" 255  80   0)    ; red-orange
+    ("d"  255 150   0)    ; orange
+    ("d#" 200 200   0)    ; yellow-green
+    ("e"  230 220   0)    ; yellow
+    ("f"   30 200  30)    ; green
+    ("f#"   0 200 180)    ; teal
+    ("g"   30 100 255)    ; blue
+    ("g#"  80  50 255)    ; indigo
+    ("a"  140  30 220)    ; purple
+    ("a#" 200  30 150)    ; magenta
+    ("b"  200  50 255)))  ; violet
+
+(defun note-color-rgb (note-name)
+  "Return (r g b) list for a note name."
+  (let ((entry (assoc note-name *note-colors* :test #'string=)))
+    (if entry (cdr entry) '(80 80 80))))
+
+;;; ── Keyboard mapping: evdev keycode → (note-name . octave-offset) ──
+
+(defvar *key-note-map* (make-hash-table :test 'eql))
+
+(defun init-key-note-map ()
+  "Populate keycode → note mapping (QWERTY layout matching JS notepat)."
+  (clrhash *key-note-map*)
+  ;; Lower octave naturals
+  (setf (gethash ac-native.input:+key-c+ *key-note-map*) '("c" . 0))
+  (setf (gethash ac-native.input:+key-d+ *key-note-map*) '("d" . 0))
+  (setf (gethash ac-native.input:+key-e+ *key-note-map*) '("e" . 0))
+  (setf (gethash ac-native.input:+key-f+ *key-note-map*) '("f" . 0))
+  (setf (gethash ac-native.input:+key-g+ *key-note-map*) '("g" . 0))
+  (setf (gethash ac-native.input:+key-a+ *key-note-map*) '("a" . 0))
+  (setf (gethash ac-native.input:+key-b+ *key-note-map*) '("b" . 0))
+  ;; Lower octave sharps
+  (setf (gethash ac-native.input:+key-v+ *key-note-map*) '("c#" . 0))
+  (setf (gethash ac-native.input:+key-s+ *key-note-map*) '("d#" . 0))
+  (setf (gethash ac-native.input:+key-w+ *key-note-map*) '("f#" . 0))
+  (setf (gethash ac-native.input:+key-r+ *key-note-map*) '("g#" . 0))
+  (setf (gethash ac-native.input:+key-q+ *key-note-map*) '("a#" . 0))
+  ;; Upper octave naturals
+  (setf (gethash ac-native.input:+key-h+ *key-note-map*) '("c" . 1))
+  (setf (gethash ac-native.input:+key-i+ *key-note-map*) '("d" . 1))
+  (setf (gethash ac-native.input:+key-j+ *key-note-map*) '("e" . 1))
+  (setf (gethash ac-native.input:+key-k+ *key-note-map*) '("f" . 1))
+  (setf (gethash ac-native.input:+key-l+ *key-note-map*) '("g" . 1))
+  (setf (gethash ac-native.input:+key-m+ *key-note-map*) '("a" . 1))
+  (setf (gethash ac-native.input:+key-n+ *key-note-map*) '("b" . 1))
+  ;; Upper octave sharps
+  (setf (gethash ac-native.input:+key-t+ *key-note-map*) '("c#" . 1))
+  (setf (gethash ac-native.input:+key-y+ *key-note-map*) '("d#" . 1))
+  (setf (gethash ac-native.input:+key-u+ *key-note-map*) '("f#" . 1))
+  (setf (gethash ac-native.input:+key-o+ *key-note-map*) '("g#" . 1))
+  (setf (gethash ac-native.input:+key-p+ *key-note-map*) '("a#" . 1))
+  ;; Extension: +2 octave
+  (setf (gethash ac-native.input:+key-semicolon+ *key-note-map*) '("c" . 2))
+  (setf (gethash ac-native.input:+key-apostrophe+ *key-note-map*) '("c#" . 2))
+  (setf (gethash ac-native.input:+key-rightbrace+ *key-note-map*) '("d" . 2))
+  ;; Sub-octave
+  (setf (gethash ac-native.input:+key-z+ *key-note-map*) '("a#" . -1))
+  (setf (gethash ac-native.input:+key-x+ *key-note-map*) '("b" . -1)))
+
+;;; ── Wave types ──
+
+(defvar *wave-names* #("sine" "triangle" "sawtooth" "square" "noise"))
+(defvar *wave-index* 0)
+(defvar *octave* 4)
+
+;;; ── Active voices and trails ──
+
+(defvar *active-voices* (make-hash-table :test 'eql)
+  "Keycode → voice-id for currently held keys.")
+
+(defvar *active-notes* (make-hash-table :test 'eql)
+  "Keycode → (note-name . actual-octave) for currently held keys.")
+
+(defvar *trails* (make-hash-table :test 'equal)
+  "note-name → brightness (1.0 → 0.0) for recently released notes.")
+
+;;; ── Background color state ──
+
+(defvar *bg-r* 20)
+(defvar *bg-g* 20)
+(defvar *bg-b* 25)
+
+;;; ── FPS tracking ──
+
+(defvar *fps-display* 0)
+(defvar *fps-accum* 0.0d0)
+(defvar *fps-samples* 0)
+(defvar *fps-last-time* 0.0d0)
+
+;;; ── ESC triple-press ──
+
+(defvar *esc-count* 0)
+(defvar *esc-last-frame* 0)
+
+;;; ── Main ──
+
 (defun main ()
-  "AC Native OS entry point."
-  ;; Log to stderr (visible on serial console)
+  "AC Native OS entry point — boots directly into notepat."
   (format *error-output* "~%════════════════════════════════════~%")
-  (format *error-output* "  AC Native OS (Common Lisp)~%")
+  (format *error-output* "  notepat (Common Lisp)~%")
   (format *error-output* "  SBCL ~A~%" (lisp-implementation-version))
   (format *error-output* "════════════════════════════════════~%~%")
   (force-output *error-output*)
 
-  ;; Try to init display
+  ;; Init key map
+  (init-key-note-map)
+
+  ;; Init display
   (let ((display (handler-case (ac-native.drm:drm-init)
                    (error (e)
-                     (format *error-output* "[cl] DRM init error: ~A~%" e)
+                     (format *error-output* "[notepat] DRM error: ~A~%" e)
                      (force-output *error-output*)
                      nil))))
     (unless display
-      (format *error-output* "[cl] FATAL: no display — sleeping 30s~%")
+      (format *error-output* "[notepat] FATAL: no display~%")
       (force-output *error-output*)
       (sleep 30)
       (return-from main 1))
···
            (sw (floor dw scale))
            (sh (floor dh scale))
            (screen (fb-create sw sh))
-           (graph (make-graph :fb screen :screen screen)))
+           (graph (make-graph :fb screen :screen screen))
+           (input (ac-native.input:input-init dw dh scale))
+           (audio (ac-native.audio:audio-init))
+           (frame 0))
 
-      (format *error-output* "[cl] display: ~Dx~D  scale: ~D  screen: ~Dx~D~%"
+      (format *error-output* "[notepat] ~Dx~D scale:~D → ~Dx~D~%"
               dw dh scale sw sh)
+      (format *error-output* "[notepat] audio: ~A~%"
+              (if audio "OK" "FAILED"))
       (force-output *error-output*)
 
-      ;; Main loop — just cycle colors
+      ;; Font init
+      (font-init)
+
+      ;; Main loop
       (setf *running* t)
-      (let ((frame 0))
-        (unwind-protect
-            (loop while *running* do
-              (incf frame)
-              ;; Cycle background
-              (let* ((t-val (* frame 0.02))
-                     (r (floor (+ 40 (* 40 (sin t-val)))))
-                     (g (floor (+ 20 (* 20 (sin (* t-val 1.3))))))
-                     (b (floor (+ 80 (* 80 (sin (* t-val 0.7)))))))
-                (graph-wipe graph (make-color :r r :g g :b b))
+      (unwind-protect
+          (loop while *running* do
+            (incf frame)
 
-                ;; White box in center
-                (graph-ink graph (make-color :r 255 :g 255 :b 255 :a 200))
-                (graph-box graph (- (floor sw 2) 30) (- (floor sh 2) 30) 60 60)
+            ;; FPS tracking
+            (let ((now (monotonic-time-ms)))
+              (when (> *fps-last-time* 0.0d0)
+                (incf *fps-accum* (- now *fps-last-time*))
+                (incf *fps-samples*)
+                (when (>= *fps-samples* 30)
+                  (setf *fps-display* (round (/ 30000.0d0 *fps-accum*)))
+                  (setf *fps-accum* 0.0d0 *fps-samples* 0)))
+              (setf *fps-last-time* now))
 
-                ;; Orange circle
-                (graph-ink graph (make-color :r 255 :g 140 :b 50))
-                (graph-circle graph (floor sw 2) (floor sh 2) 20))
+            ;; ── Input ──
+            (dolist (ev (ac-native.input:input-poll input))
+              (let ((type (ac-native.input:event-type ev))
+                    (code (ac-native.input:event-code ev)))
 
-              ;; Present
-              (ac-native.drm:drm-present display screen scale)
-              (frame-sync-60fps)
+                ;; ── Key down ──
+                (when (eq type :key-down)
+                  ;; ESC: triple-press to quit
+                  (when (= code ac-native.input:+key-esc+)
+                    (if (> (- frame *esc-last-frame*) 90)
+                        (setf *esc-count* 0))
+                    (incf *esc-count*)
+                    (setf *esc-last-frame* frame)
+                    (when (and audio (< *esc-count* 3))
+                      (audio-synth audio :type 3 ; square
+                                   :tone (if (= *esc-count* 1) 440.0d0 660.0d0)
+                                   :duration 0.08d0 :volume 0.15d0
+                                   :attack 0.002d0 :decay 0.06d0))
+                    (when (>= *esc-count* 3)
+                      (setf *running* nil)))
 
-              ;; Exit after 10 seconds (for testing)
-              (when (> frame 600)
-                (setf *running* nil)))
+                  ;; Power button
+                  (when (= code ac-native.input:+key-power+)
+                    (setf *running* nil))
 
-          ;; Cleanup
-          (fb-destroy screen)
-          (ac-native.drm:drm-destroy display)
-          (format *error-output* "[cl] shutdown~%")
-          (force-output *error-output*))))))
+                  ;; Number keys: set octave
+                  (when (and (>= code ac-native.input:+key-1+)
+                             (<= code ac-native.input:+key-9+))
+                    (setf *octave* (1+ (- code ac-native.input:+key-1+))))
+
+                  ;; Arrow up/down: octave
+                  (when (= code ac-native.input:+key-up+)
+                    (setf *octave* (min 9 (1+ *octave*))))
+                  (when (= code ac-native.input:+key-down+)
+                    (setf *octave* (max 1 (1- *octave*))))
+
+                  ;; Tab: cycle wave type
+                  (when (= code ac-native.input:+key-tab+)
+                    (setf *wave-index* (mod (1+ *wave-index*) 5))
+                    ;; Confirmation blip
+                    (when audio
+                      (let ((tones #(660.0d0 550.0d0 440.0d0 330.0d0 220.0d0)))
+                        (audio-synth audio :type *wave-index*
+                                     :tone (aref tones *wave-index*)
+                                     :duration 0.07d0 :volume 0.18d0
+                                     :attack 0.002d0 :decay 0.06d0))))
+
+                  ;; Note keys
+                  (let ((mapping (gethash code *key-note-map*)))
+                    (when (and mapping
+                               (not (gethash code *active-voices*))
+                               audio)
+                      (let* ((note-name (car mapping))
+                             (oct-delta (cdr mapping))
+                             (actual-octave (+ *octave* oct-delta))
+                             (freq (note-to-freq note-name actual-octave))
+                             ;; Pan: lower notes left, higher notes right
+                             (idx (position note-name *chromatic* :test #'string=))
+                             (semitones (+ (* (- actual-octave 4) 12) (or idx 0)))
+                             (pan (max -0.8d0 (min 0.8d0 (/ (- semitones 12) 15.0d0))))
+                             (voice-id (audio-synth audio
+                                                    :type *wave-index*
+                                                    :tone freq
+                                                    :volume 0.7d0
+                                                    :duration 0  ; sustain
+                                                    :attack 0.005d0
+                                                    :decay 0.1d0
+                                                    :pan pan)))
+                        (setf (gethash code *active-voices*) voice-id)
+                        (setf (gethash code *active-notes*)
+                              (cons note-name actual-octave))))))
+
+                ;; ── Key up ──
+                (when (eq type :key-up)
+                  (let ((voice-id (gethash code *active-voices*)))
+                    (when (and voice-id audio)
+                      (audio-synth-kill audio voice-id)
+                      (remhash code *active-voices*)
+                      ;; Start trail
+                      (let ((note-info (gethash code *active-notes*)))
+                        (when note-info
+                          (setf (gethash note-info *trails*) 1.0)
+                          (remhash code *active-notes*))))))))
+
+            ;; ── Trail decay ──
+            (let ((dead nil))
+              (maphash (lambda (note val)
+                         (let ((new-val (- val 0.025)))
+                           (if (<= new-val 0.0)
+                               (push note dead)
+                               (setf (gethash note *trails*) new-val))))
+                       *trails*)
+              (dolist (n dead) (remhash n *trails*)))
+
+            ;; ── Compute background color from active notes ──
+            (let ((n (hash-table-count *active-notes*)))
+              (if (> n 0)
+                  (let ((tr 0) (tg 0) (tb 0))
+                    (maphash (lambda (code note-info)
+                               (declare (ignore code))
+                               (let ((rgb (note-color-rgb (car note-info))))
+                                 (incf tr (first rgb))
+                                 (incf tg (second rgb))
+                                 (incf tb (third rgb))))
+                             *active-notes*)
+                    ;; Lerp toward target (darkened)
+                    (let ((target-r (floor (* (floor tr n) 35) 100))
+                          (target-g (floor (* (floor tg n) 35) 100))
+                          (target-b (floor (* (floor tb n) 35) 100)))
+                      (setf *bg-r* (+ *bg-r* (floor (- target-r *bg-r*) 4)))
+                      (setf *bg-g* (+ *bg-g* (floor (- target-g *bg-g*) 4)))
+                      (setf *bg-b* (+ *bg-b* (floor (- target-b *bg-b*) 4)))))
+                  ;; Decay to dark
+                  (progn
+                    (setf *bg-r* (+ *bg-r* (floor (- 20 *bg-r*) 8)))
+                    (setf *bg-g* (+ *bg-g* (floor (- 20 *bg-g*) 8)))
+                    (setf *bg-b* (+ *bg-b* (floor (- 25 *bg-b*) 8))))))
+
+            ;; ── Paint ──
+            (graph-wipe graph (make-color :r *bg-r* :g *bg-g* :b *bg-b*))
+
+            ;; Draw trails — horizontal bars per note+octave
+            (maphash (lambda (trail-key val)
+                       ;; trail-key is (note-name . octave)
+                       (let* ((note-name (car trail-key))
+                              (oct (cdr trail-key))
+                              (rgb (note-color-rgb note-name))
+                              (note-idx (or (position note-name *chromatic* :test #'string=) 0))
+                              ;; Unique Y per note+octave: semitone index relative to octave 1
+                              (semi (+ (* (- oct 1) 12) note-idx))
+                              (total-semitones (* 9 12))  ; octaves 1-9
+                              (bar-h (max 2 (floor (- sh 30) total-semitones)))
+                              (bar-y (+ 14 (floor (* semi (- sh 30)) total-semitones)))
+                              (bar-w (max 1 (floor (* val sw))))
+                              (bar-x (floor (- sw bar-w) 2))
+                              (alpha (max 1 (min 255 (floor (* val 200))))))
+                         (graph-ink graph (make-color :r (first rgb)
+                                                     :g (second rgb)
+                                                     :b (third rgb)
+                                                     :a alpha))
+                         (graph-box graph bar-x bar-y bar-w bar-h)))
+                     *trails*)
+
+            ;; Draw active note indicators — bright bars
+            (maphash (lambda (code note-info)
+                       (declare (ignore code))
+                       (let* ((note-name (car note-info))
+                              (oct (cdr note-info))
+                              (rgb (note-color-rgb note-name))
+                              (note-idx (or (position note-name *chromatic* :test #'string=) 0))
+                              (semi (+ (* (- oct 1) 12) note-idx))
+                              (total-semitones (* 9 12))
+                              (bar-h (max 2 (floor (- sh 30) total-semitones)))
+                              (bar-y (+ 14 (floor (* semi (- sh 30)) total-semitones))))
+                         (graph-ink graph (make-color :r (min 255 (+ (first rgb) 40))
+                                                     :g (min 255 (+ (second rgb) 40))
+                                                     :b (min 255 (+ (third rgb) 40))
+                                                     :a 220))
+                         (graph-box graph 0 bar-y sw bar-h)))
+                     *active-notes*)
+
+            ;; Status bar (bottom)
+            (let ((status (format nil "~A  OCT:~D  ~Dfps"
+                                  (aref *wave-names* *wave-index*)
+                                  *octave*
+                                  *fps-display*)))
+              (graph-ink graph (make-color :r 180 :g 180 :b 180 :a 200))
+              (font-draw graph status 3 (- sh 12)))
+
+            ;; "notepat" title (top-left, dim)
+            (graph-ink graph (make-color :r 100 :g 100 :b 110 :a 150))
+            (font-draw graph "notepat" 3 3)
+
+            ;; Active voice count (top-right)
+            (let ((vc (hash-table-count *active-voices*)))
+              (when (> vc 0)
+                (let ((txt (format nil "~D" vc)))
+                  (graph-ink graph (make-color :r 200 :g 200 :b 200 :a 180))
+                  (font-draw graph txt (- sw (* (length txt) 6) 3) 3))))
+
+            ;; ── Present ──
+            (ac-native.drm:drm-present display screen scale)
+            (frame-sync-60fps))
+
+        ;; ── Cleanup ──
+        ;; Kill all active voices
+        (when audio
+          (maphash (lambda (code voice-id)
+                     (declare (ignore code))
+                     (audio-synth-kill audio voice-id))
+                   *active-voices*)
+          (audio-destroy audio))
+        (ac-native.input:input-destroy input)
+        (fb-destroy screen)
+        (ac-native.drm:drm-destroy display)
+        (format *error-output* "[notepat] shutdown~%")
+        (force-output *error-output*)))))

fedac/native/cl/packages.lisp

···
            #:graph-plot #:graph-line #:graph-box #:graph-circle))
 
 (defpackage :ac-native.font
-  (:use :cl :ac-native.graph :ac-native.framebuffer)
-  (:export #:font-init #:font-draw #:font-measure
-           #:font-draw-matrix #:font-measure-matrix))
+  (:use :cl :ac-native.color :ac-native.graph :ac-native.framebuffer)
+  (:export #:font-init #:font-draw #:font-measure))
 
 (defpackage :ac-native.input
   (:use :cl :cffi :ac-native.syscalls)
   (:export #:input-init #:input-destroy #:input-poll
-           #:make-event #:event-type #:event-key #:event-x #:event-y))
+           #:make-event #:event-type #:event-key #:event-code #:event-x #:event-y
+           ;; Special keys
+           #:+key-esc+ #:+key-backspace+ #:+key-tab+ #:+key-enter+
+           #:+key-leftctrl+ #:+key-space+ #:+key-f1+
+           #:+key-up+ #:+key-down+ #:+key-left+ #:+key-right+
+           #:+key-home+ #:+key-end+ #:+key-power+
+           #:+key-minus+ #:+key-equal+
+           ;; Number row
+           #:+key-1+ #:+key-2+ #:+key-3+ #:+key-4+ #:+key-5+
+           #:+key-6+ #:+key-7+ #:+key-8+ #:+key-9+ #:+key-0+
+           ;; QWERTY rows
+           #:+key-q+ #:+key-w+ #:+key-e+ #:+key-r+ #:+key-t+
+           #:+key-y+ #:+key-u+ #:+key-i+ #:+key-o+ #:+key-p+
+           #:+key-leftbrace+ #:+key-rightbrace+
+           #:+key-a+ #:+key-s+ #:+key-d+ #:+key-f+ #:+key-g+
+           #:+key-h+ #:+key-j+ #:+key-k+ #:+key-l+
+           #:+key-semicolon+ #:+key-apostrophe+
+           #:+key-z+ #:+key-x+ #:+key-c+ #:+key-v+ #:+key-b+
+           #:+key-n+ #:+key-m+))
 
 (defpackage :ac-native.alsa
   (:use :cl :cffi)