-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathvoid.html
More file actions
5185 lines (4873 loc) · 239 KB
/
Copy pathvoid.html
File metadata and controls
5185 lines (4873 loc) · 239 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
<title>VOID</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Chakra+Petch:wght@300;400;600;700&family=IBM+Plex+Mono:wght@400;500&family=Michroma&display=swap" rel="stylesheet">
<style>
:root{
--void:#02070c;
--accent:#7df0ff; /* driven by core energy at runtime */
--accent-mid:rgba(125,240,255,.5);
--accent-dim:rgba(125,240,255,.3);
--accent-ghost:rgba(125,240,255,.12);
/* the companion hue — the same energy reading, rotated round the wheel.
Everything that needs a second colour pulls from here, so the palette
widens without ever leaving the core's reading. */
--accent2:#c07dff;
--accent2-mid:rgba(192,125,255,.42);
--accent2-ghost:rgba(192,125,255,.10);
--ice:#e9fdff;
--mono:'IBM Plex Mono',ui-monospace,monospace;
--disp:'Chakra Petch','IBM Plex Mono',monospace;
/* One face for the name and nothing else. Michroma is geometric and
wide, its strokes are even enough to survive being sampled into a
mesh, and its O is a true circle - which matters, because that
counter is the horizon. */
--mark:'Michroma','Chakra Petch',monospace;
/* The module. Every size in the interface is a multiple of this, and it
is derived from both axes of the viewport rather than the width alone
— so a short landscape window scales down the same way a narrow one
does, and nothing is ever measured in fixed pixels. */
--k:clamp(10.5px,0.60vw + 0.42vh,17px);
--inset:clamp(12px,2.4vmin + 0.5rem,42px);
--micro:calc(var(--k) * .60);
--track:.20em;
--track-wide:.28em;
/* Every duration in the interface is a subdivision of the core's own
beat, written here at boot from BEAT itself. Nothing in the chrome
moves at a rate the scene does not already keep. */
--t-tick:311ms; /* BEAT/16 */
--t-fast:622ms; /* BEAT/8 */
--t-mid:1244ms; /* BEAT/4 */
--t-slow:2489ms; /* BEAT/2 */
--u:calc(var(--k) * .56); /* the baseline every panel is set on */
--ease:cubic-bezier(.22,1,.36,1);
--scan:50%; /* set from the live scan plane */
--chroma:0px; /* set from the compositor's chromatic split */
--chroma-k:0;
--talk:0; /* speech amplitude */
--energy:0; /* core load, 0..1 */
--pulse:0; /* impact envelope, decays after every pulse */
--beat:0; /* the metronome, one flash per subdivision */
--surge:0; /* the bar-line flare, when the core is working */
--px:0;--py:0; /* smoothed pointer, for parallax depth */
--shx:0px;--shy:0px; /* impact shake */
--mx:50vw;--my:50vh; /* pointer, for the reticle */
--ldx:0px;--ldy:0px; /* how far the trailing ring is behind it */
--wash-a:rgba(125,240,255,.05);
--wash-b:rgba(125,240,255,.015);
}
*{box-sizing:border-box;margin:0;padding:0}
html,body{height:100%}
body{background:var(--void);color:var(--ice);font-family:var(--mono);overflow:hidden;cursor:crosshair;-webkit-font-smoothing:antialiased}
#stage{position:fixed;inset:0;z-index:1}
canvas{display:block}
/* ambient wash — the whole room takes the core's colour, with the
companion hue pooling off-centre so the void is never flat */
#wash{position:fixed;inset:0;z-index:0;pointer-events:none;
transform:translate3d(calc(var(--px) * 12px),calc(var(--py) * 9px),0);
background:
radial-gradient(46% 46% at 68% 62%,var(--accent2-ghost) 0%,transparent 68%),
radial-gradient(58% 58% at 50% 46%,var(--wash-a) 0%,var(--wash-b) 44%,transparent 74%);
transition:background var(--t-mid) linear}
/* nebula — three slow clouds, coloured by the live accents. Pure
atmosphere: it moves too slowly to read as animation, it just keeps
the background alive. */
#nebula{position:fixed;inset:-25%;z-index:0;pointer-events:none;
filter:blur(clamp(34px,6vmin,90px));opacity:.70;mix-blend-mode:screen;
transform:translate3d(calc(var(--px) * 26px),calc(var(--py) * 18px),0)}
#nebula i{position:absolute;display:block;border-radius:50%;will-change:transform}
#nebula i:nth-child(1){width:52vmax;height:52vmax;left:6%;top:10%;
background:radial-gradient(circle,var(--accent-ghost) 0%,transparent 68%);
animation:drift1 42s ease-in-out infinite}
#nebula i:nth-child(2){width:44vmax;height:44vmax;right:2%;bottom:4%;
background:radial-gradient(circle,var(--accent2-ghost) 0%,transparent 66%);
animation:drift2 57s ease-in-out infinite}
#nebula i:nth-child(3){width:34vmax;height:34vmax;left:44%;top:38%;
background:radial-gradient(circle,var(--accent-ghost) 0%,transparent 62%);
animation:drift3 34s ease-in-out infinite}
#nebula i:nth-child(4){width:62vmax;height:28vmax;left:18%;top:54%;border-radius:48%;
background:radial-gradient(ellipse,var(--accent2-ghost) 0%,transparent 70%);
transform:rotate(-18deg);animation:drift4 68s ease-in-out infinite}
#nebula i:nth-child(5){width:26vmax;height:58vmax;right:24%;top:-6%;border-radius:45%;
background:radial-gradient(ellipse,var(--accent-ghost) 0%,transparent 72%);
transform:rotate(28deg);animation:drift5 76s ease-in-out infinite}
@keyframes drift1{0%,100%{transform:translate3d(-5vw,-3vh,0) scale(1)}
50%{transform:translate3d(7vw,5vh,0) scale(1.16)}}
@keyframes drift2{0%,100%{transform:translate3d(4vw,3vh,0) scale(1.1)}
50%{transform:translate3d(-6vw,-5vh,0) scale(.92)}}
@keyframes drift3{0%,100%{transform:translate3d(0,0,0) scale(.9)}
50%{transform:translate3d(-4vw,4vh,0) scale(1.22)}}
@keyframes drift4{0%,100%{transform:translate3d(-5vw,2vh,0) rotate(-18deg) scale(.9)}
50%{transform:translate3d(6vw,-4vh,0) rotate(-12deg) scale(1.18)}}
@keyframes drift5{0%,100%{transform:translate3d(2vw,-6vh,0) rotate(28deg) scale(1.05)}
50%{transform:translate3d(-5vw,7vh,0) rotate(35deg) scale(.88)}}
/* the scan plane, projected out of the core and across the whole screen */
#scanline{position:fixed;left:0;right:0;height:1px;z-index:2;pointer-events:none;top:-10px;
background:linear-gradient(90deg,transparent,var(--accent-ghost) 12%,var(--accent-mid) 50%,var(--accent-ghost) 88%,transparent);
opacity:0}
/* a wide soft band travelling with the hairline, so the plane reads as
depth rather than as a drawn line */
#scanline::after{content:'';position:absolute;left:0;right:0;
top:calc(var(--k) * -.5);height:calc(var(--k) + 2px);
background:linear-gradient(90deg,transparent,var(--accent2-ghost) 26%,
var(--accent-ghost) 50%,var(--accent2-ghost) 74%,transparent);
filter:blur(5px);opacity:.75}
/* routine progress, top edge — no label, just the clock */
#cycle{display:none !important}
#cycle i{display:block;height:100%;width:0;
background:linear-gradient(90deg,var(--accent2-mid),var(--accent));
box-shadow:0 0 calc(10px + var(--beat) * 8px) var(--accent);
transition:width var(--t-tick) var(--ease),opacity var(--t-fast)}
#grain{position:fixed;inset:0;z-index:3;pointer-events:none;mix-blend-mode:screen;
opacity:calc(.14 + var(--energy) * .10);
background:repeating-linear-gradient(to bottom,rgba(255,255,255,.035) 0 1px,transparent 1px 3px)}
/* the vignette closes in as the core heats, so hot states feel tighter */
::selection{background:var(--accent-mid);color:var(--void)}
:focus-visible{outline:1px solid var(--accent-mid);outline-offset:3px}
#cmd:focus-visible{outline:none}
#log .txt pre::-webkit-scrollbar{width:3px;height:3px}
#log .txt pre::-webkit-scrollbar-thumb{background:var(--accent-ghost)}
#log .txt pre::-webkit-scrollbar-track{background:transparent}
#vignette{position:fixed;inset:0;z-index:4;pointer-events:none;
background:radial-gradient(calc(66% - var(--energy) * 9%) calc(66% - var(--energy) * 9%)
at 50% 48%,transparent 44%,rgba(1,4,7,.44) 100%)}
/* CRT. An aperture grille of vertical RGB triads, horizontal scanlines,
the tube's own edge shading, and the slow bright band of a refresh that
never quite syncs. Kept light enough to read through — it should feel
like the surface the interface is being displayed on, not a filter over
the top of it. */
#crt{position:fixed;inset:0;z-index:9;pointer-events:none;overflow:hidden;
animation:crtFlicker 7.2s steps(1) infinite}
#crt::before{content:'';position:absolute;inset:0;mix-blend-mode:screen;
opacity:calc(.42 + var(--energy) * .26);
background:repeating-linear-gradient(90deg,
rgba(255,26,80,.038) 0 1px,
rgba(30,255,132,.034) 1px 2px,
rgba(38,120,255,.038) 2px 3px,
transparent 3px 4px)}
#crt::after{content:'';position:absolute;inset:0;
background:
repeating-linear-gradient(0deg,rgba(0,0,0,.075) 0 1px,transparent 1px 3px),
radial-gradient(140% 132% at 50% 50%,transparent 66%,rgba(0,0,0,.16) 100%)}
@keyframes crtFlicker{0%,96%,100%{opacity:1}97%{opacity:.93}98%{opacity:1}99%{opacity:.96}}
#glitch{position:fixed;inset:0;z-index:8;pointer-events:none;opacity:0;mix-blend-mode:screen;
background:linear-gradient(90deg,transparent 30%,rgba(255,255,255,.07) 30.5%,transparent 31%)}
@keyframes glitchFlash{0%{opacity:0}5%{opacity:1}8%{opacity:0}10%{opacity:.5}13%{opacity:0}100%{opacity:0}}
/* corner marks only — no full frame */
/* A scale down the left edge. The scan plane is a real position in the
scene, so it gets a real readout: the tick it is passing lights, its
neighbours half-light, and the plane appears to travel the frame rather
than just cross it. */
#ruler{position:fixed;left:calc(var(--inset) - 3px);top:50%;height:54vh;z-index:5;
transform:translateY(-50%);pointer-events:none;
display:flex;flex-direction:column;justify-content:space-between}
#ruler b{display:block;width:calc(var(--k) * .27);height:1px;background:var(--accent-ghost);opacity:.55;
transition:width var(--t-tick) var(--ease),background var(--t-tick),opacity var(--t-tick)}
#ruler b.near{width:calc(var(--k) * .54);background:var(--accent2-mid);opacity:.8}
#ruler b.on{width:calc(var(--k) * .95);background:var(--accent);opacity:1;
box-shadow:0 0 calc(5px + var(--surge) * 8px) var(--accent)}
#corners{position:fixed;inset:var(--inset);z-index:5;pointer-events:none}
.c{position:absolute;width:calc(var(--k) * .8);height:calc(var(--k) * .8)}
.c::before,.c::after{content:'';position:absolute;background:var(--accent-mid);
box-shadow:0 0 calc(4px + var(--talk) * 10px) var(--accent-ghost);transition:background var(--t-fast)}
.c::before{width:calc(var(--k) * .7 + var(--energy) * var(--k) * .7 + var(--beat) * var(--k) * .34);height:1px}
.c::after{width:1px;height:calc(var(--k) * .7 + var(--energy) * var(--k) * .7 + var(--beat) * var(--k) * .34);
background:var(--accent2-mid)}
.tl{top:0;left:0}.tl::before,.tl::after{top:0;left:0}
.tr{top:0;right:0}.tr::before,.tr::after{top:0;right:0}
.bl{bottom:0;left:0}.bl::before,.bl::after{bottom:0;left:0}
.br{bottom:0;right:0}.br::before,.br::after{bottom:0;right:0}
#hud{position:fixed;inset:0;z-index:6;pointer-events:none;
transform:scale(calc(1 + var(--camera-zoom,0) * .004));transform-origin:50% 50%;
transition:transform var(--t-tick) linear}
.mod{position:absolute}
/* The chrome assembles itself once the core is linked, in the order you
would read it — and afterwards it sits at four different depths above
the scene, so moving the pointer moves the layers by different amounts
and the interface stops being flat glass. */
#mark,#tel,#log,#dock,#stats{opacity:0;transform:translateY(7px);
transition:opacity var(--t-mid) ease,transform var(--t-mid) var(--ease)}
body.up #mark,body.up #tel,body.up #log,body.up #dock,body.up #stats{opacity:1}
body.up #mark {transform:translate3d(calc(var(--px) * -17px + var(--shx)),calc(var(--py) * -10px + var(--shy)),0);transition-delay:.10s}
body.up #tel {transform:translate3d(calc(var(--px) * -12px + var(--shx)),calc(var(--py) * -8px + var(--shy)),0);transition-delay:.26s}
body.up #stats{transform:translate3d(calc(var(--px) * -9px + var(--shx)),calc(var(--py) * -6px + var(--shy)),0);transition-delay:.40s}
body.up #log {transform:translate3d(calc(var(--px) * -7px + var(--shx)),calc(var(--py) * -4px + var(--shy)),0);transition-delay:.52s}
body.up #dock {transform:translate3d(calc(var(--px) * -4px + var(--shx)),calc(var(--py) * -2px + var(--shy)),0);transition-delay:.64s}
/* once everything has arrived the layers track the pointer directly */
body.settled #mark,body.settled #tel,body.settled #stats,
body.settled #log,body.settled #dock{transition:opacity var(--t-fast) ease}
/* a corner readout: what the session has actually done */
#stats{right:calc(var(--inset) + var(--u) * 2);bottom:calc(var(--inset) + var(--u) * 9);
text-align:right;padding-right:calc(var(--u) * 1.4);border-right:1px solid var(--accent-ghost);
transition:border-color var(--t-fast)}
#stats div{margin-bottom:var(--u);display:flex;justify-content:flex-end;
align-items:baseline;gap:var(--u)}
#stats i{font-style:normal;font-family:var(--disp);font-weight:600;
font-size:var(--micro);letter-spacing:var(--track);text-transform:uppercase;
color:var(--accent-dim);transition:color var(--t-fast)}
#stats b{font-family:var(--disp);font-weight:400;font-size:calc(var(--k) * .80);
font-variant-numeric:tabular-nums;color:rgba(233,253,255,.62);min-width:5ch;
transition:color var(--t-fast)}
/* the reticle: the pointer becomes an instrument, with a ring that lags
behind it the way a heavy sight would */
body{cursor:none}
#cmd{cursor:text}
#reticle{position:fixed;left:0;top:0;z-index:10;pointer-events:none;opacity:0;
transform:translate3d(var(--mx),var(--my),0);transition:opacity var(--t-fast)}
body.pointer #reticle{opacity:1}
#reticle b{position:absolute;left:calc(var(--k) * -.1);top:calc(var(--k) * -.1);
width:calc(var(--k) * .2);height:calc(var(--k) * .2);border-radius:50%;
background:var(--accent);box-shadow:0 0 calc(4px + var(--energy) * 8px) var(--accent)}
#reticle::before,#reticle::after{content:'';position:absolute;top:0;height:1px;
background:var(--accent-mid);opacity:calc(.35 + var(--beat) * .3)}
#reticle::before{left:calc(var(--k) * -1);width:calc(var(--k) * .6)}
#reticle::after{left:calc(var(--k) * .4);width:calc(var(--k) * .6)}
#reticle u{position:absolute;left:calc(var(--k) * -.88);top:calc(var(--k) * -.88);
width:calc(var(--k) * 1.76);height:calc(var(--k) * 1.76);border-radius:50%;
border:1px solid var(--accent-ghost);
transform:translate3d(var(--ldx),var(--ldy),0) scale(calc(.85 + var(--pulse) * .7))}
#reticle i{position:absolute;left:calc(var(--k) * -.34);top:calc(var(--k) * -.34);
width:calc(var(--k) * .68);height:calc(var(--k) * .68);border-radius:50%;
border:1px solid var(--accent2-ghost);
transform:rotate(calc(var(--energy) * 180deg)) scale(calc(1 + var(--beat) * .5))}
/* the sight opens up as the core works harder */
#reticle u{border-color:var(--accent-ghost)}
body.working #reticle u{border-style:dashed}
body.working #reticle::before{left:calc(var(--k) * -1.28);width:calc(var(--k) * .8)}
body.working #reticle::after{left:calc(var(--k) * .54);width:calc(var(--k) * .8)}
@media(hover:none){body{cursor:auto}#reticle{display:none}}
/* Wordmark. The letters are not type with an effect on them — they are a
mesh, sampled from the letterforms into nodes and triangulated, drawn in
whatever colour the core is currently running. It breathes at rest, the
scan plane travels through it, and on every state change it breaks apart
and pulls itself back together. The dot is exempt: it is the core in
miniature, and the core does not come apart. */
#mark{top:calc(var(--inset) + var(--u) * 2);left:calc(var(--inset) + var(--u) * 2)}
#mark .wrap{position:relative;display:block}
#markcanvas{display:block;image-rendering:auto}
/* the word still exists for anything that reads rather than looks */
#mark h1.sr{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);
white-space:nowrap;margin:-1px;padding:0;border:0}
/* the rule is a meter: it fills with the core's energy */
#mark .rule{margin-top:var(--u);height:1px;width:calc(var(--k) * 11);position:relative;
background:linear-gradient(90deg,var(--accent-ghost),transparent 78%)}
#mark .rule i{position:absolute;left:0;top:0;height:100%;width:0;
background:linear-gradient(90deg,var(--accent),var(--accent2-mid));
box-shadow:0 0 calc(5px + var(--beat) * 5px) var(--accent-ghost);
transition:width var(--t-fast) var(--ease),background var(--t-fast)}
#stateline{margin-top:var(--u);display:flex;align-items:center;gap:calc(var(--u) * 1.1)}
/* The mark is a picture of the identity face, so the readout beneath it
is set in the mono instead — identity and instrument, not one voice at
two sizes. */
#statename{font-family:var(--mono);font-weight:500;
font-size:calc(var(--k) * .60);letter-spacing:var(--track);text-transform:uppercase;
color:var(--accent);transition:color var(--t-fast),opacity var(--t-fast);white-space:nowrap;
opacity:calc(.68 + var(--beat) * .22)}
/* one tick per state, the current one lit */
#statedots{display:flex;align-items:flex-end;gap:2px;height:calc(var(--k) * .48)}
#statedots b{display:block;width:1px;height:calc(var(--k) * .2);background:var(--accent-ghost);
transition:height var(--t-tick) var(--ease),background var(--t-tick),opacity var(--t-tick);opacity:.7}
#statedots b.on{height:calc(var(--k) * .48);background:var(--accent);
box-shadow:0 0 calc(5px + var(--beat) * 6px) var(--accent);opacity:1}
#statedots b.near{height:calc(var(--k) * .34);background:var(--accent2-mid);opacity:.9}
/* three readouts — same spine, sweep, split and flicker as the rest of the UI */
/* Telemetry. Read like an instrument rather than a dashboard: labels in
the identity face, numbers in the display face on tabular figures, and
bars built from discrete divisions echoing the dial ring on the core.
Each fill carries its own flow, running at the rate of the thing it is
measuring, and each row keeps a short history behind it — the same idea
as the trails in the scene, at the scale of a readout. */
#tel{top:calc(var(--inset) + var(--u) * 2);right:calc(var(--inset) + var(--u) * 2);
width:calc(var(--k) * 10.6);padding-right:calc(var(--u) * 1.5);border-right:1px solid var(--accent-ghost);
transition:border-color var(--t-fast)}
#tel .r{margin-bottom:calc(var(--u) * 2);text-align:right;position:relative}
#tel .r::after{content:'';position:absolute;right:calc(var(--u) * -1.6);top:calc(var(--u));height:1px;
width:calc(var(--u) * .65 + var(--beat) * var(--u) * .5);
background:var(--accent-mid);opacity:calc(.5 + var(--beat) * .4);
transition:background var(--t-fast)}
#tel .k{font-family:var(--disp);font-weight:600;
font-size:var(--micro);letter-spacing:var(--track);text-transform:uppercase;
color:var(--accent-dim);transition:color var(--t-fast)}
#tel .v{display:flex;align-items:baseline;justify-content:flex-end;gap:calc(var(--u) * .5);
margin-top:calc(var(--u) * .5);height:calc(var(--u) * 2.5)}
#tel .v b{position:relative;font-family:var(--disp);font-weight:400;font-size:calc(var(--k) * 1.06);
letter-spacing:.03em;font-variant-numeric:tabular-nums;
transition:color var(--t-fast) linear,text-shadow var(--t-fast) linear}
#tel .v em{font-style:normal;font-family:var(--mono);font-size:calc(var(--k) * .58);
letter-spacing:.08em;color:var(--accent-dim);
transition:color var(--t-fast)}
/* chromatic ghosts, offset by the same value that splits the frame */
#tel .v b::before,#tel .v b::after{content:attr(data-v);position:absolute;top:0;right:0;
pointer-events:none;mix-blend-mode:screen;font-variant-numeric:tabular-nums;
opacity:calc(.12 + var(--chroma-k) * .42)}
#tel .v b::before{color:#ff3a3a;transform:translateX(calc(var(--chroma) * -1))}
#tel .v b::after {color:#3aa8ff;transform:translateX(var(--chroma))}
#tel .spark{display:block;width:100%;height:calc(var(--u) * 2);margin-top:calc(var(--u) * .5);opacity:.85}
/* the track is divided, and the fill lights the divisions it reaches */
#tel .bar{height:max(2px,calc(var(--k) * .20));margin-top:calc(var(--u) * .5);position:relative;
background:
repeating-linear-gradient(90deg,var(--accent-ghost) 0 1px,transparent 1px 4px),
linear-gradient(90deg,
transparent 0%,
var(--accent2-ghost) calc(var(--scan) - 20%),
var(--accent-ghost) var(--scan),
var(--accent2-ghost) calc(var(--scan) + 20%),
transparent 100%)}
#tel .bar i{position:absolute;inset:0 auto 0 0;height:100%;width:0;
background-image:repeating-linear-gradient(90deg,
currentColor 0 1px,transparent 1px 4px);
transition:width var(--t-fast) var(--ease),color var(--t-fast) linear,
background-position var(--t-tick) linear}
#tel .bar u{position:absolute;top:calc(var(--k) * -.13);width:1px;height:calc(var(--k) * .46);left:0;opacity:.75;
transition:left var(--t-fast) linear,background var(--t-fast) linear,
box-shadow var(--t-fast) linear}
/* when nothing is being asked of it, the labels breathe rather than sit */
@keyframes listen{0%,100%{opacity:.5}50%{opacity:1}}
body.quiet #tel .k,body.quiet #stats i{animation:listen var(--t-slow) ease-in-out infinite}
body.quiet #tel .r:nth-child(2) .k{animation-delay:calc(var(--t-tick) * -2)}
body.quiet #tel .r:nth-child(3) .k{animation-delay:calc(var(--t-tick) * -4)}
/* Log. Nothing here scrolls away: as new lines arrive, the old ones are
drawn toward the core — up and inward, shrinking, dimming and blurring
with distance — until the core takes them. The age of a line is one
custom property, and every part of that motion is derived from it, so
the whole column moves as one field rather than as separate animations. */
#log{bottom:calc(var(--inset) + var(--u) * 9);left:calc(var(--inset) + var(--u) * 2);width:min(62ch,50vw);
font-size:calc(var(--k) * .74);line-height:calc(var(--u) * 3);color:rgba(233,253,255,.55);
max-height:44vh;overflow:visible;
display:flex;flex-direction:column;justify-content:flex-end;padding-left:calc(var(--u) * 1.4);
border-left:0;transition:border-color var(--t-fast);--spine-top:0px;--spine-h:0px}
#log::before{content:'';position:absolute;left:0;top:var(--spine-top);width:1px;height:var(--spine-h);
background:linear-gradient(to bottom,var(--accent-mid),var(--accent-ghost));
box-shadow:0 0 calc(4px + var(--pulse) * 6px) var(--accent-ghost);
opacity:calc(.55 + var(--energy) * .25);pointer-events:none;
transition:top 420ms var(--ease),height 420ms var(--ease),opacity var(--t-fast)}
#log .line{--a:0;--lk:0;--orb-x:0px;--orb-y:0px;--orb-r:0deg;
display:flex;gap:calc(var(--u) * 1.4);position:relative;
transform:translate3d(var(--orb-x),var(--orb-y),0) rotate(var(--orb-r));
transform-origin:left center;
opacity:calc(1 - var(--a) * .085 + var(--lk) * .10);
filter:none;
will-change:transform;
transition:transform 420ms cubic-bezier(.22,1,.36,1),opacity var(--t-mid) linear}
#log .line+.line{margin-top:calc(var(--u) * .5)}
#log .line::before{content:'';position:absolute;left:calc(var(--u) * -1.5);top:calc(var(--u) * 1.35);height:1px;
width:calc(var(--k) * .34 + var(--lk) * var(--k) * .34);
background:currentColor;opacity:calc(.3 - var(--a) * .03 + var(--lk) * .4)}
/* Who said it is a mark, not a word. The core's colour at the moment the
line was written is kept, so the column reads down the page as a history
of the machine's temperature — and the forty repetitions of its own name
are gone. */
#log .tag{flex:0 0 calc(var(--k) * .48);position:relative;padding-top:calc(var(--k) * .2)}
#log .tag::before{content:'';position:absolute;left:1px;top:calc(var(--u) * 1.1);
width:calc(var(--k) * .34);height:calc(var(--k) * .34);border-radius:50%;
background:var(--c,var(--accent));
box-shadow:0 0 calc(4px + var(--lk) * 7px) var(--c,var(--accent))}
#log .line.user .tag::before{background:none;border:1px solid rgba(233,253,255,.5);
box-shadow:none;width:calc(var(--k) * .27);height:calc(var(--k) * .27)}
#log .line.step .tag::before{width:3px;height:3px;left:2px;top:calc(var(--u) * 1.25);opacity:.7}
#log .txt{flex:1;min-width:0}
#log .line.user{color:rgba(233,253,255,.86)}
#log .line.user .tag{color:rgba(233,253,255,.4)}
#log .line.fresh .tag,#log .line.fresh .txt{animation:rise .34s backwards}
#log .line.fresh .txt{animation:rise .34s backwards,flashIn 1.1s ease-out}
/* the last of the fall: the core takes the line */
#log .line.absorb{transition:transform var(--t-mid) var(--ease),opacity var(--t-mid) ease-in;
transform:translateY(-10px);opacity:0;filter:none}
@keyframes rise{from{opacity:0;transform:translateY(3px)}to{opacity:1;transform:none}}
@keyframes flashIn{0%{color:#fff;text-shadow:0 0 12px var(--accent-mid)}100%{color:inherit;text-shadow:none}}
/* rendered reply body — markdown wearing the same clothes as the HUD */
#log .txt p{margin:0 0 .28em;line-height:calc(var(--u) * 2.75)}
#log .txt p:last-child{margin-bottom:0}
#log .txt strong{font-weight:500;color:var(--ice);text-shadow:0 0 9px var(--accent-ghost)}
#log .txt em{font-style:italic;color:rgba(233,253,255,.74)}
#log .txt del{opacity:.42}
#log .txt code{font-family:var(--mono);font-size:calc(var(--k) * .70);letter-spacing:.02em;
color:var(--accent);background:var(--accent-ghost);padding:1px 4px}
#log .txt pre{margin:.45em 0;padding:calc(var(--u) * 1.1) calc(var(--u) * 1.4);border-left:1px solid var(--accent-mid);
background:rgba(255,255,255,.03);overflow:auto;max-height:26vh;pointer-events:auto}
#log .txt pre code{display:block;white-space:pre;background:none;padding:0;
color:rgba(233,253,255,.9);font-size:calc(var(--k) * .70);line-height:1.7}
#log .txt pre[data-lang]::before{content:attr(data-lang);display:block;margin-bottom:calc(var(--u) * .9);
font-size:var(--micro);letter-spacing:var(--track);text-transform:uppercase;color:var(--accent-dim)}
#log .txt ul,#log .txt ol{list-style:none;margin:.25em 0 .35em;padding-left:0;
line-height:calc(var(--u) * 2.75)}
#log .txt li{position:relative}
#log .txt ul>li{padding-left:calc(var(--k) * .95)}
#log .txt ul>li::before{content:'';position:absolute;left:2px;top:.9em;
width:calc(var(--k) * .34);height:1px;
background:var(--accent-mid)}
#log .txt ol{counter-reset:n}
#log .txt ol>li{counter-increment:n;padding-left:calc(var(--k) * 1.6)}
#log .txt ol>li::before{content:counter(n,decimal-leading-zero);position:absolute;left:0;top:1px;
font-size:var(--micro);letter-spacing:.12em;color:var(--accent-dim)}
#log .txt h1,#log .txt h2,#log .txt h3{font-family:var(--disp);font-weight:600;
font-size:calc(var(--k) * .74);letter-spacing:var(--track);text-transform:uppercase;
color:var(--accent);margin:.5em 0 .2em}
#log .txt blockquote{margin:.3em 0;padding-left:calc(var(--u) * 1.2);border-left:1px solid var(--accent-ghost);
color:rgba(233,253,255,.6)}
#log .txt hr{border:0;height:1px;margin:.55em 0;
background:linear-gradient(90deg,var(--accent-ghost),transparent)}
#log .txt a{color:var(--accent);text-decoration:none;border-bottom:1px solid var(--accent-ghost);
pointer-events:auto}
#log .txt table{border-collapse:collapse;width:100%;margin:.4em 0;font-size:calc(var(--k) * .70);line-height:1.7}
#log .txt th,#log .txt td{text-align:left;vertical-align:top;
padding:3px calc(var(--u) * 1.25) 3px 0;
border-bottom:1px solid var(--accent-ghost)}
#log .txt th{font-size:var(--micro);letter-spacing:var(--track);text-transform:uppercase;
font-weight:400;color:var(--accent-dim)}
/* a tool step is a status line, not speech */
#log .line.step .txt{font-size:calc(var(--k) * .70);letter-spacing:.04em;color:rgba(233,253,255,.42)}
#log .line.step .txt b{font-weight:400;color:var(--accent-dim);
text-transform:uppercase;letter-spacing:var(--track);font-size:var(--micro)}
/* input */
#dock{position:fixed;left:calc(var(--inset) + var(--u) * 2);right:calc(var(--inset) + var(--u) * 2);
bottom:calc(var(--inset) + var(--u) * 2);z-index:7;pointer-events:auto;max-width:none}
#dock::before{content:'';position:absolute;left:-6%;right:-6%;
bottom:calc(var(--k) * -2.6);height:clamp(80px,16vh,180px);
pointer-events:none;z-index:-1;
background:radial-gradient(58% 100% at 50% 100%,var(--accent-ghost),transparent 72%);
opacity:calc(.30 + var(--energy) * .55 + var(--pulse) * .25)}
#dockline{height:1px;
background:linear-gradient(90deg,
var(--accent2-ghost) 0%,
var(--accent2-mid) calc(var(--scan) - 30%),
var(--accent-mid) calc(var(--scan) - 18%),
var(--accent) var(--scan),
var(--accent-mid) calc(var(--scan) + 18%),
var(--accent2-mid) calc(var(--scan) + 30%),
var(--accent2-ghost) 100%)}
#dockrow{display:flex;align-items:center;gap:calc(var(--u) * 1.5);padding:calc(var(--u) * 2) 0 0}
/* the prompt is the dot again, one size down: same object, same signals */
#caret{position:relative;flex:0 0 auto;width:calc(var(--k) * .48);height:calc(var(--k) * .48);
transition:transform var(--t-tick) var(--ease)}
#caret::before{content:'';position:absolute;inset:2px;border-radius:50%;
background:var(--accent);
box-shadow:0 0 calc(3px + var(--talk) * 12px) var(--accent);
transform:scale(calc(.85 + var(--talk) * .5 + var(--pulse) * .5));
transition:background var(--t-fast)}
#caret::after{content:'';position:absolute;inset:0;border-radius:50%;
border:1px solid var(--accent-ghost);
transform:scale(calc(.9 + var(--beat) * .35 + var(--pulse) * .9));
opacity:calc(.5 + var(--beat) * .35)}
#cmd{flex:1;background:transparent;border:0;outline:0;color:var(--ice);font-family:var(--mono);
font-size:calc(var(--k) * .84);letter-spacing:.05em;caret-color:var(--accent);
transition:letter-spacing var(--t-fast) ease}
#cmd::placeholder{color:rgba(233,253,255,.22);letter-spacing:.12em;
transition:color var(--t-fast)}
#dock.live #dockline{filter:drop-shadow(0 0 5px var(--accent-ghost))}
#dock.live #cmd{letter-spacing:.075em}
#dock.live #cmd::placeholder{color:rgba(233,253,255,.32)}
#dockline{transition:filter var(--t-fast) ease}
/* Loading screen. The same mesh the wordmark is made of, drawn large and
scattered, knitting itself together as the core comes up: the nodes fly
in from the dark with streaks behind them, the triangulation forms only
where they have arrived, and an arc closes around the whole thing as it
loads. Nothing here is a spinner or a bar with a percentage on it — it
is the interface's own material, doing the one thing it does. */
#boot{position:fixed;inset:0;z-index:11;background:var(--void);display:flex;
align-items:center;justify-content:center;flex-direction:column;
gap:clamp(14px,3.2vmin,34px);transition:opacity var(--t-fast) ease}
#boot.done{opacity:0;pointer-events:none}
#bootstage{display:block}
#bootline{display:flex;align-items:baseline;gap:calc(var(--u) * 2);
min-width:min(calc(var(--k) * 20),62vw);justify-content:space-between}
#boottext{font-family:var(--disp);font-weight:600;
font-size:var(--micro);letter-spacing:var(--track);text-transform:uppercase;
color:var(--accent-dim);transition:color var(--t-fast)}
#bootpct{font-family:var(--disp);font-weight:400;font-size:calc(var(--k) * .74);
font-variant-numeric:tabular-nums;color:var(--accent);opacity:.75}
#bootbar{width:min(calc(var(--k) * 20),62vw);height:1px;background:var(--accent-ghost);position:relative}
#bootbar i{display:block;height:100%;width:0;
background:linear-gradient(90deg,var(--accent2-mid),var(--accent));
box-shadow:0 0 8px var(--accent-ghost)}
/* Below a certain width there is not enough room for four panels around
the core, so the interface sheds them in the order of what they are
worth: the edge scale first, then the session readout, then the
sparklines and the units. Whatever is left keeps its full behaviour
rather than becoming a cut-down version of itself. */
@media(max-width:900px){
#log{width:min(46ch,58vw)}
#ruler{display:none}
}
@media(max-width:680px){
#stats{display:none}
#log{width:auto;right:calc(var(--inset) + var(--u) * 2);max-height:38vh}
#tel{width:calc(var(--k) * 8.4)}
#tel .spark{display:none}
#tel .r{margin-bottom:calc(var(--u) * 1.4)}
}
@media(max-width:430px){
#tel{width:calc(var(--k) * 7)}
#tel .v em{display:none}
#statedots{display:none}
#log{bottom:calc(var(--inset) + var(--u) * 8);max-height:32vh}
}
/* a short window is as much of a constraint as a narrow one */
@media(max-height:560px){
#log{max-height:30vh}
#tel .spark{display:none}
#stateline{display:none}
}
@media(prefers-reduced-motion:reduce){
#log .line,#log .line.fresh .txt,#log .line.fresh .tag{animation:none}
#log .line{transition:none}
#nebula i{animation:none}
#crt{animation:none}
}
/* Chat-first layout: remove the top-left wordmark/meter and give that
space to the conversation without disturbing the runtime hooks. */
#mark{display:none !important}
#log{
top:calc(var(--inset) + var(--u) * 1.5);
bottom:calc(var(--inset) + var(--u) * 9);
left:calc(var(--inset) + var(--u) * 2);
width:min(82ch,64vw);
max-height:none;
justify-content:flex-end;
}
@media(max-width:900px){
#log{width:min(68ch,70vw)}
}
@media(max-width:680px){
#log{
top:calc(var(--inset) + var(--u));
right:calc(var(--inset) + var(--u) * 2);
width:auto;
max-height:none;
}
}
@media(max-width:430px){
#log{bottom:calc(var(--inset) + var(--u) * 8);max-height:none}
}
@media(max-height:560px){
#log{top:calc(var(--inset) + var(--u));max-height:none}
}
/* ============================================================
IMMERSIVE COHERENCE PASS
All chrome responds to the same core field rather than running
unrelated decorative animations.
============================================================ */
:root{--orb-x:50%;--orb-y:50%;--ui-drift-x:0px;--ui-drift-y:0px;--field-glow:.25}
#hud::before{content:'';position:fixed;inset:0;pointer-events:none;z-index:-1;
background:
radial-gradient(34vmax 34vmax at var(--orb-x) var(--orb-y),rgba(255,255,255,.018),transparent 58%),
radial-gradient(58vmax 42vmax at var(--orb-x) var(--orb-y),var(--accent-ghost),transparent 72%);
opacity:calc(.22 + var(--energy) * .20 + var(--pulse) * .13);
filter:blur(calc(2px + var(--energy) * 5px));
transition:opacity var(--t-fast) linear}
#tel,#stats{will-change:transform,filter;
filter:drop-shadow(0 0 calc(5px + var(--energy) * 12px) var(--accent-ghost))}
#tel{transform:translate3d(calc(var(--ui-drift-x) * -0.48px),calc(var(--ui-drift-y) * -0.38px),0)}
#stats{transform:translate3d(calc(var(--ui-drift-x) * -0.28px),calc(var(--ui-drift-y) * -0.22px),0)}
body.settled #tel,body.settled #stats{transition:filter var(--t-fast) linear}
#tel .r{transform:translateZ(0);will-change:transform,opacity;
animation:uiFloat 7.7s ease-in-out infinite}
#tel .r:nth-child(2){animation-delay:calc(var(--t-tick) * -5)}
#tel .r:nth-child(3){animation-delay:calc(var(--t-tick) * -9)}
@keyframes uiFloat{0%,100%{transform:translate3d(0,0,0)}50%{transform:translate3d(0,-2px,0)}}
#log::before{box-shadow:
0 0 calc(4px + var(--energy) * 12px) var(--accent-ghost),
0 0 calc(12px + var(--pulse) * 18px) var(--accent-ghost);
opacity:calc(.38 + var(--energy) * .38 + var(--pulse) * .20)}
#log .line{will-change:transform,opacity,filter}
#log .line .txt{filter:drop-shadow(0 0 calc(var(--lk) * 5px) var(--accent-ghost))}
#dock{transform:translate3d(calc(var(--ui-drift-x) * 0.12px),calc(var(--ui-drift-y) * 0.10px),0);
will-change:transform,filter}
#dockline{position:relative;overflow:visible;
box-shadow:0 0 calc(5px + var(--energy) * 13px) var(--accent-ghost)}
#dockline::after{content:'';position:absolute;left:var(--scan);top:-2px;width:5px;height:5px;
border-radius:50%;transform:translate(-50%,-50%) scale(calc(.55 + var(--beat) * .65));
background:var(--accent);box-shadow:0 0 12px var(--accent),0 0 25px var(--accent-ghost);
opacity:calc(.35 + var(--energy) * .45)}
#dockrow{transition:transform var(--t-fast) var(--ease)}
#dock.live #dockrow{transform:translateY(-1px)}
#corners{filter:drop-shadow(0 0 calc(4px + var(--energy) * 9px) var(--accent-ghost))}
#ruler{filter:drop-shadow(0 0 calc(3px + var(--energy) * 7px) var(--accent-ghost))}
#reticle{filter:drop-shadow(0 0 calc(3px + var(--energy) * 7px) var(--accent-ghost))}
#immersion-vignette{position:fixed;inset:0;z-index:4;pointer-events:none;
background:
radial-gradient(32vmax 32vmax at var(--orb-x) var(--orb-y),transparent 20%,rgba(0,0,0,.05) 67%,rgba(0,0,0,.14) 100%),
linear-gradient(115deg,transparent 22%,var(--accent-ghost) 50%,transparent 78%);
mix-blend-mode:screen;opacity:calc(.12 + var(--energy) * .12 + var(--pulse) * .10);
transform:translate3d(calc(var(--ui-drift-x) * -0.18px),calc(var(--ui-drift-y) * -0.14px),0)}
@media(prefers-reduced-motion:reduce){#tel .r{animation:none}#dock,#tel,#stats,#immersion-vignette{transform:none}}
/* ============================================================
DIRECTED FRAME PASS
Two ideas run through everything below. First: the chrome is
mounted to the same camera the scene is, so when the director
takes an angle the interface leans with it instead of sitting
on top of it like a sticker. Second: nothing here animates on
its own schedule — every motion is driven by --energy, --beat,
--surge, --pulse, --talk or --cine, which is to say by the core.
============================================================ */
/* the frame follows the director's roll, at a quarter of the angle:
enough for the eye to accept it as one space, never enough to make
the type crooked */
#hud{
transform:
rotate(calc(var(--cine-roll,0deg) * -.22))
scale(calc(1 + var(--camera-zoom,0) * .004 + var(--cine,0) * .006));
transition:transform var(--t-tick) linear}
#wash{transform:translate3d(calc(var(--px) * 12px),calc(var(--py) * 9px),0)
rotate(calc(var(--cine-roll,0deg) * .5))}
#immersion-vignette{transform:
translate3d(calc(var(--ui-drift-x) * -0.18px),calc(var(--ui-drift-y) * -0.14px),0)
rotate(calc(var(--cine-roll,0deg) * .4))}
#nebula{transform:translate3d(calc(var(--px) * 26px),calc(var(--py) * 18px),0)
rotate(calc(var(--cine-roll,0deg) * .8)) scale(calc(1 + var(--cine,0) * .03))}
/* the flare: the core's own light spilling onto the display surface.
It has no animation of its own — it is lit entirely by the surge and
impact envelopes, so it only ever fires when the machine does. */
#flare{position:fixed;inset:0;z-index:4;pointer-events:none;mix-blend-mode:screen;
background:
radial-gradient(18vmax 18vmax at var(--orb-x) var(--orb-y),
rgba(255,255,255,.16),var(--accent-ghost) 38%,transparent 70%),
radial-gradient(46vmax 30vmax at var(--orb-x) var(--orb-y),
var(--accent-ghost),transparent 72%);
filter:blur(calc(6px + var(--surge,0) * 14px));
opacity:calc(var(--surge,0) * .34 + var(--pulse,0) * .30 + var(--beat,0) * .05);
transition:opacity 90ms linear}
/* an aperture around the whole frame: four edges that brighten with the
core and flash on the beat. It replaces the idea of a border with the
idea of an opening. */
#aperture{position:fixed;inset:0;z-index:5;pointer-events:none;
opacity:calc(.35 + var(--energy,0) * .5)}
#aperture i{position:absolute;display:block;background:linear-gradient(90deg,
transparent,var(--accent-ghost) 18%,var(--accent-mid) 50%,var(--accent-ghost) 82%,transparent);
filter:blur(.5px);
transition:opacity var(--t-tick) linear,transform var(--t-tick) var(--ease)}
#aperture .n,#aperture .s{left:8%;right:8%;height:1px;
opacity:calc(.20 + var(--beat,0) * .45 + var(--surge,0) * .4);
transform:scaleX(calc(.86 + var(--energy,0) * .14))}
#aperture .n{top:calc(var(--inset) * .45)}
#aperture .s{bottom:calc(var(--inset) * .45)}
#aperture .w,#aperture .e{top:14%;bottom:14%;width:1px;
background:linear-gradient(180deg,transparent,var(--accent2-ghost) 20%,
var(--accent2-mid) 50%,var(--accent2-ghost) 80%,transparent);
opacity:calc(.16 + var(--talk,0) * .35 + var(--pulse,0) * .4);
transform:scaleY(calc(.86 + var(--energy,0) * .14))}
#aperture .w{left:calc(var(--inset) * .45)}
#aperture .e{right:calc(var(--inset) * .45)}
/* corner marks answer the beat as well as the energy, so the four
corners and the aperture edges tick together */
.c::before,.c::after{
opacity:calc(.55 + var(--beat,0) * .35 + var(--surge,0) * .25)}
/* the scan plane blooms as it passes, rather than being a constant line */
#scanline{filter:drop-shadow(0 0 calc(3px + var(--energy,0) * 9px) var(--accent-ghost))}
/* ---- the log ---- */
/* A line does not simply appear: the light that wrote it travels across
it once, left to right, at the speed of the core's own tick. */
#log .line.fresh{position:relative}
#log .txt{position:relative;overflow:visible}
#log .line.fresh .txt::after{content:'';position:absolute;inset:-2px -6px;
pointer-events:none;mix-blend-mode:screen;
background:linear-gradient(100deg,transparent 38%,var(--accent-ghost) 50%,transparent 62%);
animation:wipe 780ms var(--ease) forwards}
@keyframes wipe{from{transform:translateX(-38%);opacity:.9}
to{transform:translateX(38%);opacity:0}}
#log .line.fresh .tag::after{content:'';position:absolute;left:-3px;top:calc(var(--u) * .8);
width:calc(var(--k) * .62);height:calc(var(--k) * .62);border-radius:50%;
border:1px solid var(--c,var(--accent));
animation:tagRing 900ms var(--ease) forwards}
@keyframes tagRing{from{transform:scale(.35);opacity:.85}
to{transform:scale(1.5);opacity:0}}
/* the mark on the newest line keeps time with the core */
#log .line:last-child .tag::before{
box-shadow:0 0 calc(5px + var(--beat,0) * 9px + var(--talk,0) * 10px) var(--c,var(--accent))}
/* ---- telemetry ---- */
/* the fills are not static blocks: the division pattern flows at the rate
of the reading it belongs to, so a busy channel visibly runs */
#tel .bar i{background-size:8px 100%;animation:flow 1.9s linear infinite;
animation-duration:calc(var(--t-mid) * (1.35 - var(--energy,0) * .5))}
@keyframes flow{to{background-position:8px 0}}
#tel .bar u{box-shadow:0 0 calc(3px + var(--surge,0) * 9px) var(--accent)}
/* the row currently being written to leans a hair toward the reader */
#tel .r{transition:transform var(--t-fast) var(--ease),filter var(--t-fast) linear}
body.working #tel .r{filter:drop-shadow(0 0 calc(2px + var(--energy,0) * 6px) var(--accent-ghost))}
#tel .k,#stats i{transition:color var(--t-fast),letter-spacing var(--t-mid) var(--ease)}
body.working #tel .k{letter-spacing:calc(var(--track) + .04em);color:var(--accent)}
/* ---- the dock ---- */
/* while the core is listening the prompt keeps a slow ring going out from
it; while it is answering, the ring is driven by speech instead */
#dock.live #caret{transform:scale(1.06)}
#dockrow{position:relative}
#dockrow::before{content:'';position:absolute;left:0;
top:calc(var(--u) * 2);
width:calc(var(--k) * .48);height:calc(var(--k) * .48);
border-radius:50%;border:1px solid var(--accent-mid);pointer-events:none;opacity:0}
body.up #dockrow::before{animation:listenRing var(--t-slow) ease-out infinite}
@keyframes listenRing{0%{opacity:.5;transform:scale(.8)}
70%{opacity:0;transform:scale(3.4)}
100%{opacity:0;transform:scale(3.4)}}
#cmd:focus{letter-spacing:.085em}
#dockline{transform:scaleX(calc(.985 + var(--energy,0) * .015 + var(--pulse,0) * .01));
transform-origin:50% 50%}
/* ---- the reticle ---- */
/* it is a sight, so when the core is working it behaves like one: the
outer ring turns, and the turn rate is the core's load */
body.working #reticle u{animation:sight 4.2s linear infinite;
animation-duration:calc(var(--t-slow) * (1.6 - var(--energy,0)))}
@keyframes sight{to{transform:translate3d(var(--ldx),var(--ldy),0)
scale(calc(.85 + var(--pulse) * .7)) rotate(360deg)}}
/* ---- while the director is moving ---- */
/* the display surface reacts to the move the way a real one would: the
tube brightens a little, the grain lifts, the vignette closes in */
body.cine #grain{opacity:calc(.14 + var(--energy) * .10 + var(--cine,0) * .07)}
body.cine #vignette{background:radial-gradient(
calc(66% - var(--energy) * 9% - var(--cine,0) * 6%)
calc(66% - var(--energy) * 9% - var(--cine,0) * 6%)
at 50% 48%,transparent 44%,rgba(1,4,7,.5) 100%)}
#crt::before{opacity:calc(.42 + var(--energy) * .26 + var(--cine,0) * .10)}
/* the horizon reading was being measured and never used: when the core
pulls, the whole interface loses a little of its colour to it */
#hud,#log,#dock{filter:saturate(calc(1 + var(--horizon-fall,0) * .5))}
@media(prefers-reduced-motion:reduce){
#log .line.fresh .txt::after,#log .line.fresh .tag::after,
#tel .bar i,body.up #dockrow::before,body.working #reticle u{animation:none}
#flare{opacity:calc(var(--surge,0) * .18)}
#hud{transform:none}
}
</style>
</head>
<body>
<div id="wash"></div>
<div id="immersion-vignette"></div>
<div id="nebula"><i></i><i></i><i></i><i></i><i></i></div>
<div id="stage"></div>
<div id="scanline"></div>
<div id="grain"></div>
<div id="vignette"></div>
<div id="flare"></div>
<div id="aperture"><i class="n"></i><i class="s"></i><i class="w"></i><i class="e"></i></div>
<div id="glitch"></div>
<div id="crt"></div>
<div id="cycle"><i></i></div>
<div id="ruler"></div>
<div id="reticle"><u></u><i></i><b></b></div>
<div id="corners">
<div class="c tl"></div><div class="c tr"></div><div class="c bl"></div><div class="c br"></div>
</div>
<div id="hud">
<div class="mod" id="mark">
<div class="wrap"><h1 class="sr">VOID</h1><canvas id="markcanvas"></canvas></div>
<div class="rule"><i id="markmeter"></i></div>
<div id="stateline">
<span id="statename">standby</span>
<span id="statedots"></span>
</div>
</div>
<div class="mod" id="tel">
<div class="r">
<div class="k">Throughput</div>
<div class="v"><b id="v-out">0</b><em>tok/s</em></div>
<canvas class="spark" id="sp-out"></canvas>
<div class="bar"><i id="b-out"></i><u id="p-out"></u></div>
</div>
<div class="r">
<div class="k">Context</div>
<div class="v"><b id="v-int">0.0</b><em>%</em></div>
<canvas class="spark" id="sp-int"></canvas>
<div class="bar"><i id="b-int"></i><u id="p-int"></u></div>
</div>
<div class="r">
<div class="k" id="k-load">Activity</div>
<div class="v"><b id="v-load">0</b><em>%</em></div>
<canvas class="spark" id="sp-load"></canvas>
<div class="bar"><i id="b-load"></i><u id="p-load"></u></div>
</div>
</div>
<div class="mod" id="log"></div>
<div class="mod" id="stats">
<div><i>calls</i><b id="s-calls">0</b></div>
<div><i>context</i><b id="s-ctx">0k</b></div>
<div><i>lens</i><b id="s-lens">1.00</b></div>
</div>
</div>
<div id="dock">
<div id="dockline"></div>
<div id="dockrow">
<span id="caret"></span>
<input id="cmd" autocomplete="off" spellcheck="false" placeholder="say something" aria-label="Message input" />
</div>
</div>
<div id="boot">
<canvas id="bootstage"></canvas>
<div id="bootline"><span id="boottext">linking core</span><b id="bootpct">0%</b></div>
<div id="bootbar"><i></i></div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
<script>
(function(){
'use strict';
const PR=Math.min(window.devicePixelRatio||1,2);
const W=()=>innerWidth, H=()=>innerHeight;
/* ==============================================================
FIELD + ENERGY COLOR RAMP
Colour is not decoration here: it encodes how hard the core is
working. Cold blue at rest, through cyan and green, into yellow
and red as energy climbs. Mirrored in JS so the HUD matches.
============================================================== */
const FIELD=`
uniform float uTime; uniform float uAmp; uniform float uScan;
uniform float uPulse; uniform float uRadK; uniform float uEnergy;
uniform float uTint;
float field(vec3 p, float t){
float n=0.0;
n+=sin(p.x*2.1+t*1.05)*cos(p.y*1.9-t*0.85)*0.50;
n+=sin(p.y*3.7-t*1.35)*cos(p.z*3.1+t*1.20)*0.27;
n+=sin(p.z*6.3+t*1.90)*cos(p.x*5.9-t*1.55)*0.13;
n+=sin((p.x+p.y+p.z)*9.0-t*2.6)*0.06;
return n;
}
float scanGlow(float y){ return 1.0-smoothstep(0.0,0.085,abs(y-uScan)); }
vec3 ramp(float x){
x=clamp(x,0.0,1.0);
vec3 c=vec3(0.02,0.16,0.42);
c=mix(c,vec3(0.10,0.62,0.92),smoothstep(0.00,0.26,x));
c=mix(c,vec3(0.36,0.98,0.82),smoothstep(0.26,0.44,x));
c=mix(c,vec3(0.44,1.00,0.36),smoothstep(0.44,0.60,x));
c=mix(c,vec3(1.00,0.88,0.20),smoothstep(0.60,0.78,x));
c=mix(c,vec3(1.00,0.44,0.10),smoothstep(0.78,0.91,x));
c=mix(c,vec3(1.00,0.16,0.12),smoothstep(0.91,1.00,x));
return c;
}
// Rodrigues rotation about the grey axis: swings a ramp colour round the
// wheel without changing how bright it reads. Each system takes its own
// offset, so the palette opens up while every hue still comes from the
// same energy reading.
vec3 hueRot(vec3 c, float a){
const vec3 k=vec3(0.57735);
float ca=cos(a);
return c*ca + cross(k,c)*sin(a) + k*dot(k,c)*(1.0-ca);
}
`;
function fieldJS(x,y,z,t){
let n=0;
n+=Math.sin(x*2.1+t*1.05)*Math.cos(y*1.9-t*0.85)*0.50;
n+=Math.sin(y*3.7-t*1.35)*Math.cos(z*3.1+t*1.20)*0.27;
n+=Math.sin(z*6.3+t*1.90)*Math.cos(x*5.9-t*1.55)*0.13;
n+=Math.sin((x+y+z)*9.0-t*2.6)*0.06;
return n;
}
const RAMP_STOPS=[[0.00,[0.02,0.16,0.42]],[0.26,[0.10,0.62,0.92]],[0.44,[0.36,0.98,0.82]],
[0.60,[0.44,1.00,0.36]],[0.78,[1.00,0.88,0.20]],[0.91,[1.00,0.44,0.10]],
[1.00,[1.00,0.16,0.12]]];
function rampJS(x){
x=Math.max(0,Math.min(1,x));
for(let i=0;i<RAMP_STOPS.length-1;i++){
const [a,ca]=RAMP_STOPS[i],[b,cb]=RAMP_STOPS[i+1];
if(x<=b){
const f=(x-a)/(b-a||1);
return [ca[0]+(cb[0]-ca[0])*f, ca[1]+(cb[1]-ca[1])*f, ca[2]+(cb[2]-ca[2])*f];
}
}
return RAMP_STOPS[RAMP_STOPS.length-1][1];
}
// the same rotation the shaders use, so the HUD's companion hue is exactly
// the one the geometry is painted with
function hueRotJS(c,a){
const k=0.57735,ca=Math.cos(a),sa=Math.sin(a);
const [x,y,z]=c, s=(x+y+z)*(1-ca)/3;
return [x*ca+k*(z-y)*sa+s, y*ca+k*(x-z)*sa+s, z*ca+k*(y-x)*sa+s]
.map(v=>Math.max(0,Math.min(1,v)));
}
// exponential damping: same settling feel at 30fps and 144fps, where a
// plain per-frame lerp would snap on fast machines and drag on slow ones
const damp=(a,b,lambda,dt)=>b+(a-b)*Math.exp(-lambda*dt);
const decay=(v,lambda,dt)=>v*Math.exp(-lambda*dt);
/* ==============================================================
COHERENT RANDOMNESS
Nothing here calls Math.random at runtime. Variation comes from
low-discrepancy sequences instead: the golden ratio for choices,
the radical inverse for placement, the golden angle for rotation.
The result still never repeats, but it never clumps either — which
is the difference between a scene that looks alive and one that
looks noisy.
Every rate in the sim is a power of the golden ratio times one base
frequency. Oscillations built on related ratios read as composed
rather than cluttered, because they keep drifting in and out of
phase with each other instead of fighting.
============================================================== */
const PHI=1.6180339887498949;
const GA=Math.PI*(3-Math.sqrt(5)); // golden angle, 2.39996 rad
const W0=0.4817; // base rate, ~13s period
const HW=n=>W0*Math.pow(PHI,n); // harmonic ladder
const HR=[HW(-2),HW(-1),HW(0),HW(1),HW(2),HW(3),HW(4)]; // 0.18 → 3.3 rad/s
const BEAT=2*Math.PI/HR[4]; // ~4.98s, the metronome
// golden-ratio sequence: successive values land as far from each other
// as it is possible to land
let grS=0.3819660112;
const gr=()=>{grS=(grS+0.6180339887498949)%1;return grS};
const J=(v,k)=>v*(1+(gr()*2-1)*(k===undefined?.10:k));
const pick=a=>a[Math.min(a.length-1,(gr()*a.length)|0)];
// radical inverse: fills an interval evenly at every scale
function vdc(i,b){b=b||2;let f=1,r=0;while(i>0){f/=b;r+=f*(i%b);i=Math.floor(i/b)}return r}
// smaller screens get lighter populations — the look survives, the frame
// rate does too
// the population is set by how many pixels there are to fill, not by a
// breakpoint: a small window with a dense screen is still a small window
const LOW=(innerWidth*innerHeight)<620000||matchMedia('(max-width:820px)').matches;
const N=(full,low)=>LOW?low:full;
function makeSprite(soft){
const c=document.createElement('canvas');c.width=c.height=128;
const ctx=c.getContext('2d'),g=ctx.createRadialGradient(64,64,0,64,64,64);
if(soft){g.addColorStop(0,'rgba(255,255,255,1)');g.addColorStop(.18,'rgba(255,255,255,.85)');
g.addColorStop(.45,'rgba(255,255,255,.26)');g.addColorStop(.7,'rgba(255,255,255,.05)');
g.addColorStop(1,'rgba(255,255,255,0)');}
else{g.addColorStop(0,'rgba(255,255,255,1)');g.addColorStop(.09,'rgba(255,255,255,.92)');
g.addColorStop(.24,'rgba(255,255,255,.44)');g.addColorStop(.52,'rgba(255,255,255,.1)');
g.addColorStop(1,'rgba(255,255,255,0)');}
ctx.fillStyle=g;ctx.fillRect(0,0,128,128);
const t=new THREE.CanvasTexture(c);t.needsUpdate=true;return t;
}
const TEX=makeSprite(true),TEX_HARD=makeSprite(false);