By Serge Hulne

WebAssembly is opening doors for programming languages to run efficiently in the browser, and Go is among those making serious strides in this domain. SwiftlyGo is an experimental, minimalistic toolkit I created to explore how far we can push Go in the browser — using only Go, and no JavaScript.

💡 The Problem

• Modern frontend development often demands:
• A Node.js toolchain
• JavaScript frameworks like React, Vue, or Solid
• Transpilers, bundlers, linters, plugins, and loaders
• HTML/CSS/JS separated from your backend logic

Even for simple dashboards or admin tools, the setup cost is massive — especially for teams that primarily use Go on the backend.

SwiftlyGo is a declarative UI toolkit written in Go and compiled to WebAssembly, enabling developers to build browser apps using a design style inspired by SwiftUI or Jetpack Compose.

It uses :

• ❌ No Node.js
• ❌ No npm
• ❌ No bundler (Webpack, Parcel, etc.)
• ❌ No React, Vue, or JSX
• ❌ No VDOM
• ❌ No build pipeline beyond make wasm

🔍 What Is SwiftlyGo?

SwiftlyGo provides:

• A declarative widget tree defined entirely in Go
• Two-way reactive state using observables
• Browser-native rendering through Go’s syscall/js and honnef.co/go/js/dom/v2
• A small, composable widget system (button, label, layout containers, etc.)

It’s lightweight, dependency-free, and matches Go’s philosophy: keep it simple, readable, and fast.

🧠 Design Philosophy

Most frontend frameworks abstract away the DOM through virtual layers. While this is powerful, it introduces runtime complexity and large JS bundles. SwiftlyGo takes a different approach:

• Direct DOM binding: no virtual DOM, no diffing algorithm — just observable bindings.
• Minimal runtime: reactivity is handled via explicit observables and callback hooks.
• Composition over configuration: layout is done via containers (horizontal, vertical), each built with native HTML semantics under the hood.

📁 Project Structure

The repository has a flat structure with a central demo in app/main.go:

SwiftlyGo/
├── core/         # Widget definitions, observables, DOM glue
├── ui/           # Layout helpers and composition primitives
└── app/          # Demo application: tasks, counter, layout showcase

🧪 Demo Application (in app/main.go)

The demo file contains a practical showcase of the toolkit. It includes:

✔️ Features

• Diverse snippets illustrating the reactive aspects of the widgets
• A counter.
• A simple todo list.
• A version of Conways “Game of life cellulqr automaton”.

✨ Code Highlights

State definition using observables:

package main

import (
	"fmt"
	"gocore/core"
	"gocore/ui"
)

func OneWay() {
	source := core.NewObservable("")

	in := ui.NewTextField()
	in.BindTo(source)

	out := ui.NewTextField()

	btn := ui.NewButton("Copy")
	btn.OnClick(func() {
		fmt.Println("Clicked:", source.Get())
		out.SetText(source.Get())
	})

	w := ui.NewWindow()
	w.Add(in, out, btn)
	w.Run()
}

A declarative UI tree:

ui := core.NewVBox(
    core.NewText("Todo App").FontSize(20),
    core.NewHBox(
        input.BindTo(taskText),
        core.NewButton("➕").OnClick(func() {
            // Logic to add new task
        }),
    ),
    // Render the list
)

Auto-updating reactive views:

core.NewTextBound(remainingText)

This updates automatically when remainingText changes — no manual refresh needed.

⚙️ Running the App

SwiftlyGo comes with a command-line development tool located in the cmd/ directory. This tool launches a local development server and handles automatic rebuilding and live-reloading whenever you modify your Go code.

To get started:

git clone https://github.com/serge-hulne/SwiftlyGo
cd SwiftlyGo
go run ./cmd/coredev

Then open your browser at:

http://localhost:8090

🛠 What’s in cmd/coredev?

The development tool does the following:

• Watches the app/ folder for changes to .go files
• Automatically rebuilds the WASM binary using GOOS=js GOARCH=wasm
• Serves index.html, main.wasm, and wasm_exec.js
• Triggers a page reload in the browser when changes are detected

This creates a smooth workflow similar to what frontend developers expect from modern tools like Vite or Parcel, but tailored for Go+WASM development.

📈 Future Improvements

I plan to explore:

• Theme support and dark mode
• Component abstraction with reusability
• Form widgets (checkbox, radio, dropdown)
• Improved layout options (grid, scroll view)

📎 Repository

🔗 GitHub: serge-hulne/SwiftlyGo

📸 Banner

You can use this image when publishing the article on Medium:

🎯 Why It Matters

SwiftlyGo shows that Go can be used not just for backend logic or computation, but for full UI applications. It demonstrates a model where developers can write frontend UI logic in the same language and mindset as their backend, simplifying full-stack development.

It’s also a useful playground to experiment with ideas around declarative UI, state reactivity, and WASM ergonomics in Go — without involving JavaScript or large toolchains.

Le décès de PIERRE RABHI, figure emblématique de l’écologie Française, appelle quelques réflexions sur les mythes et réalités entourant la perception de l’écologie par les média et la société.

Force est de rendre homage à un homme de bien qui a voué son existence à faire connaître les enjeux de l’écologie auprès du grand public.

Comme tous les grands hommes qui ont contribué à se faire les apôtres d’une cause qui est à la fois cruciale mais méconnue à un un moment donné de l’histoire et qui, de ce fait, ont été exposés aux feux de la rampe, cette figure emblématique d’une partie du mouvement écologique en France n’est pas sans controverse Pierre Rabhi, wikipédia

Je crains qu’on ne puisse dire des choses analogues pour nombre de promoteurs et d’acteurs de la scène écologique au sens large, dans des contextes comme celui des « villages en transition » ou encore des élus de village écologistes, des promoteurs de parcs d’éoliennes et/ou de panneaux solaires, etc.

Quand on regarde de près, ces approches sont souvent utopiques, empruntes d’amateurisme; elles sont souvent le fait d’idéologues, limite sectaires, sous pression de résultats (et donc tentés de falsifier leurs résultats).

Des élus écologistes font quelquefois aussi figure de despotes imposant leur vision des choses à leurs administrés (des controverses qui ne manquent pas voir le jour à l’encontre de personnages tel que le maire de Ungersheim, par exemple) -à tort ou à raison- l’histoire nous l’apprendra.

Un autre exemple est celui de l’île de El Hierro (éoliennes plus STEP),une île soi-disante autonome en énergie, en réalité : un fiasco économique, écologique, financier sur arrière-plan d’escroqueries, qui à longtemps été montré comme un modèle de système « résilient, autonome » par des journalistes négligeant tous les signe ostensibles avertisseurs d’escroquerie et de manipulation idéologique.

On a dit de Pierre Rabhi : « Son exploitation ne fournissait pas de quoi nourrir ses employés » , c’est le aussi cas de néo-ruraux qui retournent vivre en ville après avoir risqué (paradoxalement) de mourir de faim, de froid en dépit de leurs potagers, de leurs panneaux solaires et de leur basse-cour (faute d’avoir prévu un nombre de panneaux solaires nécessaire pour fournir une énergie suffisante et faute d’avoir prévu l’acquisition d’un nombre d’hectares suffisants pour assurer leur alimentation).

Bernard Friot : « La ZAD ne peut pas fournir les outils de production de la ZAD ».

La décroissance, la sobriété sont vraisemblablement nécessaires pour essayer de construire un monde de l’après-pétrole.

Toutefois :

1. Les EnR butent sur le problème du pic des métaux (cuivre, etc.) et les impératifs d’une économie circulaire. Donc au vu d’un simple bilan des ressources en métaux et en béton, il est clair que le éoliennes ou les panneaux solaires à eux seuls ne peuvent pas permettre un transition vers l’après pétrole.

2. La globalisation est une nécessité pour l’échange de ressources nécessaires pour affronter l’après pétrole. Il devrait y avoir une loi rendant obligatoire l’affichage (via code QR) de la chaîne d’apprivoisement de tous les produits, avec en plus:

• Le calcul de l’emprunte carbone correspondante.
• Le calcul, plus généralement de l’emprunte énergétique correspondante.

Exemple affichage de la chaine d’approvisionnement d’une usine de panneaux solaire en Allemagne (Ref 1):

Quand on considère cet exemple, on s’aperçoit que c’est très loin d’être du 100% « Made in Germany »

3. Une certaine autonomie industrielle au niveau des nations est aussi nécessaire (ce n’est pas antagoniste : les deux sont nécessaires. l’autonomie « absolue » est un mythe, une pathologie. C’est du survivalisme déguisé; c’est une pathologie de la pensée d’extrême droite)

4. Une approche de l’agriculture plus respectueuse des sols est indispensable à la survie du genre humain, mais la permaculture de base appliquée littéralement n’est pas la solution (pas plus que les engrais chimiques ou les OGM, ou les monocultures à long terme).

Il faut un nouveau modèle (qui n’a pas encore été trouvé).

Dans ce cadre les OGM sont peut-être un moindre mal mais encore faut-il rendre l’accès à ces technologies elles-mêmes «durable», perenne, en faire une priorité au sens des ressources critiques (à meme titre que les matières premieres critiques).

Les dirigeants qui ignorent ce genre de contraintes physiques incontournables seront confrontés à:

• Des prix délirants de l’énergie (paralysant tout).
• L’inflation galopante que ces prix induisent inévitablement.
• Des pénuries alimentaires prolongées, à l’échelle nationale, voir continentale.
• Des disruptions de leur industrie dues aux manques d’approvisionnement en matières premières, en pièces, en composants et entrants divers : Métaux, semi-conducteurs, blé, sucre, etc.
• Les troubles économiques, sociaux, alimentaires qui vont avec.
• Les conflicts et guerres (guerres économiques et guerres tout court) qui en résultent. Cf V. Mignerot et al.

Ungersheim:

https://www.lemoniteur.fr/article/ungersheim-le-village-ou-la-transition-energetique-est-une-realite.1491949

https://fr.wikipedia.org/wiki/Ungersheim

Rabhi:

https://fr.wikipedia.org/wiki/Pierre_Rabhi

El_Hierro:

https://fr.wikipedia.org/wiki/El_Hierro

https://www.bbc.com/news/magazine-34424606

http://euanmearns.com/an-independent-evaluation-of-the-el-hierro-wind-pumped-hydro-system/

Friot_Lordon:

https://youtu.be/2_kaRuDNdno

Neo_ruraux:

https://www.lemonde.fr/livres/article/2006/10/17/neo-ruraux-gare-aux-desillusions_824426_3260.html

Pic_metaux:

https://www.lemonde.fr/blog/petrole/2012/05/08/rarefaction-des-metaux-demain-le-peak-all/

https://reporterre.net/La-croissance-verte-est-une-mystification-absolue

https://www.lemonde.fr/culture/article/2020/11/24/les-metaux-rares-la-face-noire-des-energies-vertes-devoilee-sur-arte_6060981_3246.html

https://youtu.be/E1iphq6THdc

https://mrmondialisation.org/reouverture-des-mines-en-france-un-formidable-operation-de-greenwashin/

Supply_chains:

(Ref 1) https://open.sourcemap.com/maps/5877c865325110eb1f1dd998?fbclid=IwAR0fgU_uPVNgG5KqbHpO_sibZZB1Sv5hJUCojReiOzo4OslcnFKlEnvMCdw

https://shellyfaganaz.medium.com/why-you-should-be-very-worried-about-the-supply-chain-39ee38f95fa7

Autonomy_myth:

https://www.resilience.org/stories/2019-10-18/the-myth-of-autonomy

https://energypost.eu/roadmap-to-nowhere-the-myth-of-powering-the-nation-with-renewable-energy/

prix_des_renouvelables:

https://jancovici.com/publications-et-co/articles-de-presse/pas-chere-mon-electricite-decarbonee/

https://courrierdeuropecentrale.fr/un-expert-francais-defend-le-nucleaire-les-renouvelables-sont-une-diversion/

https://courrierdeuropecentrale.fr/un-expert-francais-defend-le-nucleaire-les-renouvelables-sont-une-diversion/

Agriculture:

https://www.geo.fr/environnement/agriculture-durable-definition-principes-et-enjeux-193859

https://www.fao.org/sustainable-development-goals/overview/fao-and-post-2015/sustainable-agriculture/fr/

Mignerot:

https://www.presages.fr/blog/2018/vincent-

Ressources_critiques:

https://fr.wikipedia.org/wiki/Matières_premières_critiques

Asynchronous Cellular Automata: An Alternative to Synchronous Update Schemes in Conway’s Game of Life.

Author: Serge Hulne
Date: 2025
Duration: 5 minute read

Abstract

This paper presents an implementation of Conway’s Game of Life using asynchronous update mechanisms, departing from the traditional synchronous approach. The model employs concurrent processing where each cell operates independently with species-specific timing parameters. This approach provides a framework for studying emergent behaviors in systems without global synchronization, with potential applications in distributed computing and biological modeling.

1. Introduction

Conway’s Game of Life, introduced by John Horton Conway in 1970, represents a foundational model in cellular automaton theory. The traditional implementation employs synchronous updates where all cells transition states simultaneously at discrete time steps. This paper explores an alternative approach using asynchronous updates, where each cell operates on an independent schedule.

The motivation for this approach stems from observations in natural systems where synchronous behavior is rare. Biological systems, from neural networks to bacterial colonies, typically exhibit asynchronous dynamics. Additionally, modern distributed computing systems operate without global clocks, making asynchronous models increasingly relevant.

2. Background

2.1 Traditional Conway’s Game of Life

The standard Game of Life operates on a two-dimensional grid where each cell exists in one of two states (alive or dead). State transitions follow deterministic rules based on the count of living neighbors in the Moore neighborhood (8 adjacent cells).

2.2 Limitations of Synchronous Models

Synchronous cellular automata assume:

• Universal time steps
• Simultaneous state updates across all cells
• Perfect information propagation

These assumptions do not align with:

• Distributed systems where communication has latency
• Biological systems with variable reaction times
• Physical systems where information propagates at finite speed

3. Model Description

3.1 Asynchronous Update Mechanism

Our implementation replaces the global update cycle with independent cell processes. Each cell:

1. Maintains its own update schedule
2. Reads neighbor states asynchronously
3. Updates based on local observations

Implementation in Go:

func (c *Cell) run(wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        time.Sleep(c.reactionTime())
        c.computeNextState()
        c.applyNextState()
    }
}

3.2 Multi-Species Extension

The model incorporates three cell species with distinct timing parameters:

• Species 1 (Green): 101ms update interval
• Species 2 (Red): 102ms update interval
• Species 3 (Blue): 102ms update interval

Birth rules incorporate species competition through majority voting with stochastic tie-breaking.

3.3 Concurrency Management

The system employs:

• One goroutine per cell (lightweight threads in Go)
• Mutex-based synchronization for state access
• Read-write locks for grid-level operations

4. Implementation

4.1 Technical Architecture

• Language: Go (chosen for native concurrency support)
• Visualization: Terminal-based using tcell library
• Grid Size: Configurable, typically 50×50 cells
• Memory Usage: Approximately 2–4KB per goroutine

4.2 Synchronization Protocol

func (c *Cell) countAliveNeighbors() (green, red, blue int) {
    c.gridMu.RLock()
    defer c.gridMu.RUnlock()
    
    for _, offset := range c.neighbour8 {
        neighbor.mu.Lock()
        // Read neighbor state
        neighbor.mu.Unlock()
    }
    return
}

4.3 Visualization

The system renders to terminal with:

• Color-coded species representation
• 20Hz refresh rate
• Double-width characters for aspect ratio correction

5. Observed Behaviors

5.1 Emergent Phenomena

The asynchronous model exhibits several distinct behaviors:

1. Propagation Delays: Information spreads through the grid at finite speed rather than instantaneously
2. Local Synchronization: Adjacent cells may spontaneously synchronize through mutual interaction
3. Species Boundaries: Interfaces between species territories show complex dynamics
4. Temporal Heterogeneity: Different regions evolve at different rates

5.2 Comparison with Synchronous Model

Key differences include:

• Absence of perfectly periodic patterns
• Emergence of timing-dependent behaviors
• More gradual pattern evolution
• Potential for metastable states

6. Applications

6.1 Distributed Systems

• Modeling consensus protocols without global clocks
• Studying fault tolerance in asynchronous networks
• Analyzing propagation delays in distributed algorithms

6.2 Biological Systems

• Neural network dynamics with realistic propagation delays
• Bacterial colony growth with variable cell division rates
• Ecological models with species-specific time scales

6.3 Theoretical Computer Science

• Exploring computational universality in asynchronous systems
• Studying emergence in non-synchronized automata
• Analyzing complexity measures for concurrent systems

7. Performance Analysis

• Scalability: Linear with grid size (O(n) goroutines for n cells)
• Memory: 2–4KB per cell, totaling ~10MB for 50×50 grid
• CPU Usage: Dependent on update frequencies and mutex contention
• Synchronization Overhead: Minimal due to fine-grained locking

8. Future Research Directions

1. Parameter Studies: Systematic analysis of timing parameter effects
2. Scaling Behavior: Investigation of large-scale emergent properties
3. Energy Models: Introduction of resource constraints
4. 3D Extensions: Three-dimensional grids with additional propagation dynamics
5. Adaptive Timing: Dynamic adjustment of update rates based on local activity

9. Installation and Usage

git clone https://github.com/serge-hulne/Non-Newtonian-cellular-automata
cd Non-Newtonian-cellular-automata
go mod tidy
go run main.go

Command-line options:

• --invert: Reverse color scheme for light terminals
• Exit: Press ‘q’ or ESC

10. Conclusion

This implementation demonstrates that cellular automata can operate effectively without global synchronization. The asynchronous approach:

• Provides a more realistic model for natural systems
• Enables new types of emergent behaviors
• Offers insights into distributed computation

The model serves as a platform for investigating questions in complex systems, distributed computing, and theoretical biology where synchronous assumptions are limiting.

References

Source code available at: https://github.com/serge-hulne/Non-Newtonian-cellular-automata

Acknowledgments

Implementation utilizes the Go programming language and tcell terminal library.

Keywords: Cellular automata, asynchronous systems, Conway’s Game of Life, concurrent programming, emergent behavior, distributed systems

Implementation available in Go using goroutines and tcell. Code features per-cell concurrency, race-free updates, and terminal UI. For experimental setups, CLI flags and visualization tools are extendable.

GitHub: [https://github.com/serge-hulne/Non-Newtonian-cellular-automata]

Contact: [https://github.com/serge-hulne] for collaboration or feedback.

D. Hofstadter : Consciousness, self-reference, Gődel, IA. https://youtu.be/R6e08RnJyxo?is=nxM57I2R0e8GXXGT

Durant cet hiver particulièrement rigoureux de 1895, alors que nous nous apprêtions à entamer notre repas du soir, un fracas précipité et insistant à la porte d’entrée résonna dans toute la maison, provoquant un sursaut violent de la bonne Mrs Hudson, qui faillit lâcher le plateau portant son ragoût irlandais, l’un de ses chefs-d’œuvre culinaires les plus appréciés.
Mrs Hudson, robuste dame d’origine écossaise, était ordinairement d’un tempérament flegmatique, mais les menaces redoutables que nous avions subies durant l’affaire que j’ai relatée sous le titre « Le Signe des Quatre » avaient mis ses nerfs à rude épreuve.

J’étais sur le point de plonger ma cuillère dans ce savoureux mets lorsque Mrs Hudson reparut, précédant l’inspecteur Lestrade. Ce dernier fit irruption dans notre salon dans un état de grand désarroi : son chapeau de travers, ses vêtements en désordre, et son visage livide. Le déluge qui s’abattait sur Londres depuis l’aube avait trempé son manteau jusqu’à l’os, et des filets d’eau dévalaient sa moustache frémissante. Son apparence débraillée contrastait vivement avec le soin méticuleux qu’il apportait habituellement à sa tenue.
Holmes, la main posée sur le dossier d’un fauteuil, l’observa avec un mélange de curiosité et d’amusement.

— Mon cher Lestrade, on dirait que vous avez traversé la Tamise à la nage. Je vous en prie, éclairez-nous : quel mauvais vent vous pousse jusqu’à Baker Street à pareille heure ? dit-il en désignant d’un geste distrait le fauteuil près de la cheminée.
L’inspecteur s’y effondra lourdement, sans même songer à se débarrasser de son manteau détrempé. Son regard hagard passa de Holmes à moi, puis à la table dressée, comme s’il ne prenait que vaguement conscience d’interrompre notre repas. Il sortit un mouchoir de sa poche et s’épongea le front, bien que la pièce fût loin d’être surchauffée.

— Je vous prie de m’excuser pour cette intrusion, messieurs, balbutia-t-il d’une voix rauque d’émotion. Mais l’affaire ne souffre aucun délai — pas une minute de plus.

— Holmes, dit Lestrade, c’est le cauchemar Bruce-Partington tout recommencé, mais en pire cette fois.

— Ne me dites pas que l’Amirauté a encore égaré des documents d’importance nationale, Lestrade ? Allons, j’ose espérer que la marine n’a pas perdu sa flotte… murmura Holmes, un léger plissement au coin des lèvres trahissant son amusement.

— Ce n’est pas une affaire à plaisanter, Monsieur Holmes, protesta Lestrade en s’épongeant de nouveau le front. Il est vrai que des documents ont disparu… mais ce n’est pas tout…
Le sourcil droit de Holmes se haussa de cette manière caractéristique qui invitait l’interlocuteur à poursuivre son récit.
Je notai l’étincelle d’intensité familière dans son regard — ce petit éclat qui signifiait, pour qui savait l’interpréter, que son esprit était déjà en pleine ébullition.

— Il y a aussi, s’exclama Lestrade, ce détail infime de plusieurs tonnes de lingots d’or qui se sont volatilisées !
Un fracas de vaisselle brisée suivi d’un bruit sourd nous apprit que Mrs Hudson venait de s’évanouir.

Réprimant un juron surpris, je saisis la carafe de cognac des mains de notre hôte sans cérémonie pour porter secours à notre logeuse en syncope. Sachant qu’une main ferme est un prérequis pour tout médecin, je pris au passage la précaution d’en avaler une gorgée salutaire.
Avec l’aide de Holmes, nous parvînmes à installer Mrs Hudson sur le canapé. Quant à l’inspecteur Lestrade, il resta figé dans son fauteuil, le visage figé dans une expression de consternation absolue.
Pendant que je vérifiais le pouls de Mrs Hudson, j’entendis Holmes dire à Lestrade :

— Reprenez-vous, inspecteur. À présent… éclairez-nous.

— Une tonne d’or volée à la Royal Bank of Scotland alors que mes hommes et moi étions postés à l’intérieur comme à l’extérieur ! s’exclama Lestrade. Puis, submergé par l’émotion, il poursuivit : Holmes, c’est ma perte assurée ! Ma réputation est en lambeaux — le chef de la police exigera ma démission après une telle catastrophe. On parle d’anarchistes, de complots… certains vont même jusqu’à chuchoter qu’il y a des traîtres dans la police ! Et Jenny… Si je suis révoqué, ils risquent de la renvoyer, elle aussi — et notre petit Tommy, que va-t-il devenir ? L’asile, l’usine, la mine… Mon Dieu…
Holmes, imperturbable, servit une généreuse mesure de cognac et la tendit d’une main aussi calme que s’il offrait un biscuit.

À cet instant, Mrs Hudson entrouvrit les paupières. Elle se redressa, tenta de se lever, réussit avec mon aide, puis déclara avec cette dignité tranquille de qui est résolu à maintenir les convenances en toutes circonstances : « Messieurs, jamais une affaire de cette gravité ne trouvera son dénouement le ventre vide. Je vous en prie, honorez mon ragoût irlandais. Je vais chercher une assiette supplémentaire sur-le-champ. »

— Deux, je vous prie, Mrs Hudson, ajouta Holmes d’un ton absent, le regard déjà ailleurs. Je crois que vous aussi avez besoin de vous remettre de vos émotions.

— Mais… mais… qu’en est-il de la confidentialité de l’enquête, Monsieur Holmes ? demanda-t-elle, son accent écossais légèrement plus prononcé sous le coup de l’émotion.

— J’ai bien peur, Mrs Hudson, que vous n’ayez déjà été mise au courant des aspects les plus graves. N’est-ce pas, Lestrade ?
Lestrade acquiesça d’un signe de tête. Bien qu’encore visiblement secoué, un peu de couleur revenait peu à peu à ses joues.

- D’ailleurs, continua Holmes, tirant pensivement sur sa pipe, vous reprendrez votre récit après dîner. Il vous faut d’abord reprendre des forces.
Le repas achevé, Holmes servit à chacun de nous une tasse du café fraîchement préparé par Mrs Hudson avant qu’elle ne se retirât dans ses quartiers, après nous avoir souhaité une bonne soirée et adressé ses sympathies à l’inspecteur Lestrade.

Sortant le tabac de son unique tabatière — un vieux chausson persan en cuir passablement usé — Holmes invita Lestrade à reprendre le fil de son récit.

— Il y a trois semaines, j’ai été convoqué par le commissaire Llewelyn-Jones, commença Lestrade, sa voix plus assurée après le repas.

Je remarquai qu’à l’évocation de cet aristocrate, connu pour son mépris sans bornes envers ses subalternes, qu’il considérait comme de simples domestiques, les narines de Holmes frémirent légèrement — unique indice de son désaveu.

Celui-ci m’a informé que Sir Reginald Fitzpatrick — le directeur de la Royal Bank of Scotland — avait sollicité de l’aide au sujet de vols commis dans son établissement. Sir Reginald était convaincu que ses employés dérobaient des objets de valeur, mais il ne comprenait pas comment ils pouvaient échapper à la vigilance des détectives internes, pourtant aux aguets depuis les premiers disparus.

Le pauvre homme était au bord de la crise de nerfs, poursuivit Lestrade en secouant la tête. Il a d’abord accusé les caissiers, puis les comptables, ensuite les veilleurs de nuit, et enfin les détectives eux-mêmes. À présent, il est persuadé qu’il s’agit d’un vaste complot. Il a même pris l’habitude de se promener armé dans les bureaux, menaçant plus d’un employé.
Le commissaire m’a donc chargé d’enquêter discrètement.
Comme tous les vols étaient découverts au petit matin, j’ai jugé plus prudent de monter la garde à l’intérieur du coffre pendant la nuit, accompagné de deux de mes meilleurs agents. J’ai choisi Wilkins et Hobbes. Deux excellents éléments.
Pendant une semaine, nous avons monté la garde dans ce coffre, nuit après nuit, sans le moindre incident… jusqu’à ce que…

A NOVEL

During that particularly bitter winter of 1895, as we were about to partake of our evening repast, a most frantic and insistent rapping upon the front door resounded throughout the house, causing the good Mrs. Hudson to start violently, very nearly relinquishing her grasp upon the tray bearing the Irish Stew, which was one of her most lauded culinary accomplishments.

Mrs. Hudson was a stalwart lady of Scottish extraction, ordinarily possessed of a rather phlegmatic disposition, but the dire threats we had suffered during the affair I have chronicled under the title “The Sign of the Four” had sorely taxed her nerves.

I was on the verge of plunging my spoon into the savoury concoction when Mrs. Hudson reappeared, preceding Inspector Lestrade. The latter burst into our drawing-room in a state of considerable discomposure, his hat awry, his garments in disarray, and his countenance ashen. The deluge that had been assailing London since the early hours had thoroughly saturated his greatcoat, and rivulets of water trickled from his quivering moustache. His dishevelled appearance stood in marked contrast to his customary fastidiousness in matters of attire.

Holmes, who had been poised with one hand upon the chair back, regarded our visitor with a gleam of mingled curiosity and amusement.
“My dear Lestrade, you look as though you have wrestled with the Thames itself. Pray, what ill wind has blown you to Baker Street at such an hour?” he remarked, gesturing languidly toward the armchair nearest the hearth.
The inspector collapsed heavily into it, neglecting even to divest himself of his sodden overcoat. His harrowed gaze shifted from Holmes to myself, then to the appointed table, as if he were only dimly cognizant that he was interrupting our evening meal. He extracted a handkerchief from his pocket and mopped his brow, though the chamber was by no means overheated.

“I beg your pardon for intruding like this, gentlemen,” he stammered, his voice rough with agitation. “But the matter cannot wait — not for another moment.”
“Holmes,” said Lestrade, “it’s that Bruce Partington nightmare all over again, only this time, worse.”
“Surely not another lapse in Her Majesty’s defences, Lestrade? Tell me the Navy has not misplaced its fleet.” Holmes murmured, a faint twitch at the corner of his mouth betraying his amusement.
“This is no matter for jest, Mr. Holmes,” Lestrade protested, mopping his brow again. “There are indeed papers missing… but that’s not the whole of it…”
Holmes’s right eyebrow arched in that characteristic manner which bade his interlocutor continue with his narrative.
I detected the familiar sharpening of his gaze — the restless brilliance that signalled his faculties were already engaged.
“There is also,” Lestrade blurted out, “the small matter of several tons of gold bullion having vanished without trace!”
A cacophony of crashing crockery followed by a dull thud informed us that Mrs. Hudson had swooned away.

Suppressing a startled oath, I seized the decanter of brandy from our host’s hands without ceremony in order to hasten to the aid of our landlady in her state of syncope. Mindful that steadiness of hand is a prerequisite for any physician, I took the liberty of a swift restorative myself before attending to her pulse.
With Holmes’s assistance, we contrived to settle Mrs. Hudson upon the settee. Inspector Lestrade, for his part, remained immobile in his chair, a look of utter consternation upon his visage.
As I ascertained Mrs. Hudson’s pulse, I heard Holmes address Lestrade:
“Compose yourself, Inspector. Now — elucidate.”
“A ton of gold stolen from the Royal Bank of Scotland while my men and I were stationed both inside and out!” Lestrade exclaimed. Then, suddenly overcome with emotion, he continued, “Holmes, this will be the ruin of me! My reputation is in shreds — the Chief Inspector will demand my resignation over this catastrophe. There’s talk of anarchists and plots. Some are even whispering about traitors in the force! And what of Jenny…? They may well dismiss her as well over the disgrace — and our little Tommy, what will become of him? The workhouse, the factories, the mines… God help us.”

Holmes, unperturbed, decanted a generous measure of brandy and extended it with a hand as steady as though he were offering a biscuit.
At this juncture, Mrs. Hudson’s eyelids fluttered open. She straightened herself, made as if to rise, succeeding with my assistance, and then declared with the dignified air of one accustomed to maintaining decorum under all circumstances: “Gentlemen, no affair of gravity has ever reached a satisfactory conclusion on an empty stomach. I beseech you to do justice to my Irish Stew. I shall fetch an additional cover forthwith.”
“Two, if you please, Mrs. Hudson,” Holmes added absently, his gaze already distant. “I believe you too are in need of fortification after such a shock.”
“But… but… what of the confidential nature of the investigation, Mr. Holmes?” she asked, her Scottish brogue slightly more pronounced in her distress.
“I fear you have already been apprised of the most grievous aspects, Mrs. Hudson. Is that not so, Lestrade?”
Lestrade signified his assent with an inclination of his head. Though still visibly shaken, a modicum of colour was gradually returning to his cheeks.
“Moreover,” said Holmes, drawing thoughtfully upon his pipe, “you shall resume your account once we have dined. You must first replenish your strength.”

The repast concluded, Holmes dispensed to each of us a cup of the coffee recently prepared by Mrs. Hudson before she retired to her quarters, having wished the assembled company a pleasant evening and extended her sympathies to Inspector Lestrade.
Extracting tobacco from his singular snuffbox, which was naught but a well-worn leather Persian slipper, Holmes encouraged Lestrade to recommence the narration of his misfortunes.
“Three weeks ago, I was summoned to see Commissioner Llewelyn-Jones,” Lestrade began, his voice steadier after the meal.
I observed that at the mention of this aristocrat, notorious for his unbridled contempt for those he deemed subordinate, whom he regarded as mere menials, Holmes’s nostrils flared ever so slightly — the only outward sign of his distaste.
“This Llewelyn-Jones informed me that Sir Reginald Fitzpatrick — the head of the Royal Bank of Scotland — had sought assistance regarding thefts at his institution. Sir Reginald was convinced his staff were pilfering valuables, yet he could not fathom how they were passing undetected by the bank’s own detectives, who had been watching most carefully since the first items were reported missing.
“The poor man was nearly at his wit’s end,” Lestrade continued, shaking his head. “He began by suspecting the cashiers, then the accountants, then the night watchmen, and at last even the detectives themselves. Now he’s certain there’s some great conspiracy at work. Lately, he’s taken to carrying a pistol about the place, and has threatened his own employees more than once.
“So the Commissioner asked me to investigate the affair discreetly.
“Given that all the thefts were discovered in the morning, I judged it prudent to keep watch inside the vault at night, accompanied by two of my best men. I took Wilkins and Hobbes — excellent officers, both of them.
“For a week we maintained our vigil in that vault, night after night, without the slightest disturbance… until…”

What if building reactive web frontends didn’t require Node.js, npm, React, or JSX?

Meet Golid, a lightweight, idiomatic frontend framework written entirely in Go, compiled to WebAssembly.

Update 1
See also SwiflyGo for more functional variant:

https://medium.com/@serge-hulne/swiftlygo-declarative-webassembly-ui-in-pure-go-478103663b67

Update 2:
The the Golid code base has been modified.
There are new examples in the main.go file.

See also updated example hereunder in this article.

💡 The Problem

Modern frontend development often demands:

• A Node.js toolchain
• JavaScript frameworks like React, Vue, or Solid
• Transpilers, bundlers, linters, plugins, and loaders
• HTML/CSS/JS separated from your backend logic

Even for simple dashboards or admin tools, the setup cost is massive — especially for teams that primarily use Go on the backend.

✅ The Golid Approach

Golid (short for Go + Solid) takes inspiration from Solid.js but keeps things radically simple.

What it offers:

• 🔁 Reactive components built with native Go types
• 💡 Signals for state and reactivity (no VDOM)
• 🧩 Components written with Gomponents — a pure-Go HTML DSL
• 🪶 WebAssembly-based rendering — no JS needed
• 🛠️ TinyGo support for blazing-fast, small .wasm binaries

🔨 What Golid Does Not Use

Let’s be clear — Golid is not your average frontend framework:

• ❌ No Node.js
• ❌ No npm
• ❌ No bundler (Webpack, Parcel, etc.)
• ❌ No React, Vue, or JSX
• ❌ No VDOM
• ❌ No build pipeline beyond make wasm

Just:

• ✅ Go
• ✅ TinyGo (optional)

🧪 What Golid Code Looks Like

A simple counter component looks like this

func CounterComponent() Node {
 // Observable (represents the state of the app)
 count := golid.NewSignal(0)

 return Div(
  Style("border: 1px solid orange; padding: 10px; margin: 10px;"),

  // Bind text Element to the reactive count signal (observable)
  golid.Bind(func() Node {
   return Div(Text(fmt.Sprintf("Count = %d", count.Get())))
  }),

  // [+] Button element
  Button(
   Style("margin: 3px;"),
   Text("+"),
   golid.OnClick(func() {
    count.Set(count.Get() + 1)
   }),
  ),

  // [-] Button element
  Button(
   Style("margin: 3px;"),
   Text("-"),
   golid.OnClick(func() {
    count.Set(count.Get() - 1)
   }),
  ),
 )
}

You define your UI and logic in one place, using Go.
No macros. No templates. No transpilation.

⚡ Why Use Golid?

🧱 SimplePure Go. No JS toolchain

🧠 FamiliarWorks like Solid.js or Svelte, but in Go

🔒 PredictableExplicit state, no magic

⚡ FastFine-grained reactivity, no virtual DOM

Quick Start

🌐 Try It Out

You can check out the GitHub repo here:
👉 https://github.com/serge-hulne/Golid

🎯 The Vision

Golid isn’t trying to replace React or Vue. It’s for people who love Go and want to build UI with:

• Less complexity
• More clarity
• Minimal setup

As the framework matures, expect:

• More built-in components
• Routing
• Developer tools
• More examples and docs

❤️ Open Source and Ready for Feedback

Golid is licensed under GPL and open to contributions.
If you’re tired of 1000-dependency node_modules hell, give it a try.

👉 github.com/serge-hulne/Golid

Implementing a unwrap function in Go which emulates the corresponding Rust method can be done as follows:

package unwrap

import (
 "errors"
)

// UnwrapRaw simply returns the value or panics if there's an error.
func UnwrapRaw[T any](value T, err error) T {
 if err != nil {
  panic(err)
 }
 return value
}

// Unwrap checks for nil values, but only for pointer types.
func Unwrap[T any](value T, err error) T {
 if err != nil {
  panic(err)
 }

 // This avoids nil checking for non-pointer types
 if isNil(value) {
  panic(errors.New("nil value returned"))
 }
 return value
}

// isNil checks if a generic value is nil, but only for pointer or interface types.
func isNil[T any](value T) bool {
 // Convert to interface{} before checking for nil
 return (any(value) == nil)
}

I put this code on Github. It can be used like this:

package main

import (
 . "github.com/serge-hulne/go_unwrap"
 "fmt"
 "strconv"
)

func main() {
 fmt.Printf("Result = %v\n", Unwrap(strconv.Atoi("2"))*Unwrap(strconv.Atoi("3")))
 fmt.Printf("Result = %v\n", strconv.Itoa(Unwrap(strconv.Atoi("42"))))
}

The repositery is located at:
https://github.com/serge-hulne/go_unwrap/tree/main

My goal was to build a GUI which is:

• Portable (muti-platform).
• Simple.
• Minimalist.
• Self-explanatory.
• In which the state of the app is trivial to code (simple variables as in Svelte).

About ngiu

After studying, Flutter, SwiftUI and JetPack Compose, I set out to create my own library for coding GUIs for desktop apps.

The complete code of the the library (Go packge) plus an example (in the README) is available on GitHub: https://github.com/serge-hulne/ngiu

ngiu extends giu (github.com/AllenDang/giu) and brings SwiftUI-like coding style to giu.

Why the name ngiu ?

ngiu stands for "new giu", (just like ncurses stands for new curses).

func main() {
 wnd := giu.NewMasterWindow("Password encrypted wallet", 600, 400, 0)
 wnd.Run(loop)
}

func loop() {
 giu.SingleWindow().Layout(
  VStack(
   giu.Label("Enter a new service / password combination"),

   // Main widget
   NewWidget(formData.FormDataLayout()).
    PaddingTop(10).
    PaddingLeft(50),

   // Flexible spacer to push items below it to the bottom
   giu.Custom(func() {
    _, height := giu.GetAvailableRegion()
    giu.Dummy(0, height-30).Build() // Adjust height to control space
   }),

   // Status label at the bottom
   NewWidget(giu.Label("Status: OK")).
    BackgroundColor(NewColorByName(ColorNames.Basic.Blue)).
    ForegroundColor(NewColorByName(ColorNames.Vivid.Lime)).
    FontWeight("bold").
    PaddingTop(10),
  ),
 )
}

With ngiu, you can add padding in a fashion similar to SwiftUI:

NewWidget(formData.FormDataLayout()).
    PaddingTop(10).
    PaddingLeft(50),

Also ngiu allows you to manage a widget's colour as in SwiftUI

NewWidget(giu.Label("Status: OK")).
    BackgroundColor(NewColorByName(ColorNames.Basic.Blue)).
    ForegroundColor(NewColorByName(ColorNames.Vivid.Lime)).
    FontWeight("bold").
    PaddingTop(10),

This is made possible by the use of ngiu' widget which extends giu's Layout type, providing an expressive SwiftUI-like coding style:

// Constructor for creating a CustomWidget
func NewWidget(w giu.Widget) *Widget {
 return &Widget{w}
}

This way of structuring the code helps developers in that layout and styling benefit from auto-completion (also, it looks more familiar to a SwiftUI developer or a JetPack Compose or Flutter developer) :

Layout code auto-complete:

Styling code auto-complete:

The comple code of the app is available here:
https://github.com/serge-hulne/giu-editor

1. Using giu, the GUI of a simple text editor can be as simple as:

//*******************
// App visual layout :
//*******************

func Body() g.Widget {
 X, Y := wnd.GetSize()
 return g.Layout{
  g.Column(
   g.InputTextMultiline(&text).Size(float32(X-50), float32(Y-70)),
   g.Label("Status : "+status),
  ),
 }
}

2. The corresponding menu can be as simple to code as:

{
  "menus": [
    {
      "label": "File",
      "submenus": [
        { "label": "Open", "action": "OpenFile" },
        { "label": "Save", "action": "SaveFile" },
        { "label": "Save as", "action": "SaveFileAs" },
        { "Label": "Quit", "Action": "quit"}
      ]
    },
    {
      "label": "Help",
      "submenus": [
        { "label": "About", "action": "About" }
      ]
    }
  ]
}

3. Defining he state of the app can be as simple as declaring a few global vars:

//-----------------------------------------

//************
// App state :
//************

var text string
var filePath string
var AboutText string
var SizeX int = 800
var SizeY int = 600
var wnd *g.MasterWindow
var status string = "OK."

//-----------------------------------------

4. Each meu item needs a corresponding action, in the shape of a method:

//**************
// Save File :
//**************

func SaveFile() {
 // Check if filePath is set
 if filePath == "" {
  log.Println("No file path specified. Use 'Save As' to specify a file name.")
  return
 }

 fmt.Println("Saving file:", filePath)
 f, err := os.Create(filePath)
 if err != nil {
  log.Println("Failed to create file:", err)
  status = fmt.Sprintf("Failed to create file: %s", err)
  return
 }

 _, err = f.WriteString(text)
 if err != nil {
  log.Println("Failed to write to file:", err)
  status = fmt.Sprintf("Failed to write to file: %s", err)
  f.Close()
  return
 }

 err = f.Close()
 if err != nil {
  log.Println("Failed to close file:", err)
  status = fmt.Sprintf("Failed to close file: %s", err)
 }
 fmt.Println("File saved successfully!")
 status = "File saved successfully!"
}

The management of the menu can be abstracted away (once and for all) in its own file or package:

package main

import (
 "encoding/json"
 "log"

 _ "embed"

 g "github.com/AllenDang/giu"
)

// Define structs to represent the menu and submenu structure
type SubmenuItem struct {
 Label  string `json:"label"`
 Action string `json:"action"`
}

type MenuItem struct {
 Label    string        `json:"label"`
 Submenus []SubmenuItem `json:"submenus"`
}

type MenuData struct {
 Menus []MenuItem `json:"menus"`
}

// Actions for submenu items
func submenuAction(actionName string) func() {
 return func() {
  ActionMap[actionName]()
  menu_choice = 0
  g.Update()
 }
}

var menuData MenuData
var menu_choice = 0
var showAboutPopup bool // State variable to control the "About" popup

//go:embed menu.json
var menuJSON []byte

func loadMenu() {
 // Parse the embedded JSON file
 err := json.Unmarshal(menuJSON, &menuData)
 if err != nil {
  log.Fatalf("Failed to parse JSON: %v", err)
 }
}

func loop() {
 // Create a slice for main menu buttons
 var mainMenuItems []g.Widget
 for idx, menu := range menuData.Menus {
  // Capture index and label for each main menu button
  i := idx
  label := menu.Label

  // Append an asterisk to the label of the selected menu item
  if menu_choice == i+1 {
   label = "<" + label + ">"
  }

  // Create the button for the menu item
  mainMenuItems = append(mainMenuItems, g.Button(label).OnClick(func() {
   menu_choice = i + 1
   g.Update() // Force redraw of the UI when menu changes
  }))
 }

 // Layout for the main menus (horizontal)
 g.SingleWindow().Layout(
  g.Row(mainMenuItems...),
  g.Separator(),
  g.Row(
   g.Column(
    // Layout for submenus (vertical)
    func() g.Widget {
     if menu_choice > 0 && menu_choice <= len(menuData.Menus) {
      submenu := menuData.Menus[menu_choice-1].Submenus
      var submenuWidgets []g.Widget
      for _, sub := range submenu {
       // Add each submenu button and its associated action
       submenuWidgets = append(submenuWidgets, g.Button(sub.Label).OnClick(submenuAction(sub.Action)))
      }
      return g.Column(submenuWidgets...)
     }
     return g.Label("")
    }()),
   g.Column(Body())),
 )

 // Check if we should open the "About" popup
 if showAboutPopup {
  showAboutPopup = false // Reset the flag
  g.OpenPopup("About")
  g.Update()
 }

 // Define the "About" popup modal
 g.PopupModal("About").Layout(
  g.Label(AboutText),
  g.Button("Close").OnClick(func() {
   g.CloseCurrentPopup() // Close the popup when "Close" is clicked
  }),
 ).Build() // Ensure Build is called on the PopupModal
}

Last but not least, the actions have to be connected to the menu entries:

package main

// Auto-generated action map
var ActionMap = map[string]func(){
 "OpenFile": OpenFile,
 "SaveFile": SaveFile,
 "SaveFileAs": SaveFileAs,
 "quit": quit,
 "About": About,
}

And this "registering" of menu actions, can be automated with an other Go app, as simply as in :

package main

import (
 "encoding/json"
 "fmt"
 "io/ioutil"
 "log"
 "os"
)

// Define structs to parse the menu.json file
type SubmenuItem struct {
 Label  string `json:"label"`
 Action string `json:"action"`
}

type MenuItem struct {
 Label    string        `json:"label"`
 Submenus []SubmenuItem `json:"submenus"`
}

type MenuData struct {
 Menus []MenuItem `json:"menus"`
}

// Function to generate action_map.go
func main() {
 // Read menu.json
 menuJSON, err := ioutil.ReadFile("menu.json")
 if err != nil {
  log.Fatalf("Failed to read menu.json: %v", err)
 }

 // Parse JSON into MenuData
 var menuData MenuData
 err = json.Unmarshal(menuJSON, &menuData)
 if err != nil {
  log.Fatalf("Failed to parse JSON: %v", err)
 }

 // Create or overwrite action_map.go
 file, err := os.Create("action_map.go")
 if err != nil {
  log.Fatalf("Failed to create action_map.go: %v", err)
 }
 defer file.Close()

 // Write the package declaration and imports
 fmt.Fprintln(file, "package main\n")
 fmt.Fprintln(file, "// Auto-generated action map")
 fmt.Fprintln(file, "var ActionMap = map[string]func(){")

 // Collect unique action names and generate the map entries
 actionSet := make(map[string]bool)
 for _, menu := range menuData.Menus {
  for _, submenu := range menu.Submenus {
   if _, exists := actionSet[submenu.Action]; !exists {
    actionSet[submenu.Action] = true
    fmt.Fprintf(file, "\t\"%s\": %s,\n", submenu.Action, submenu.Action)
   }
  }
 }

 // Close the map
 fmt.Fprintln(file, "}")

 fmt.Println("action_map.go generated successfully!")
}

Conclusion :

When coding a simple app this way, only steps 1–4 are required. The rest of the code (the menu code utils) can be downloaded from:

https://github.com/serge-hulne/giu-editor

This is a short, informal draft about a hypothesis of mine regarding the nature of consciousness. It is philosophical, speculative, intuitive. It is not supposed to be rigorous, hard science at all at this stage.

it is highly speculative and subject to change.

My aim is to attempt to write a series of essays in which I will try to develop progressively a sort of logical, formal, axiomatic approach to questions like :

• Can we logically, axiomatically, mathematically define consciousness?
• How does it work, what causes it?
• Is consciousness physical? biological? material? or something else?
• Is consciousness some kind of an abstraction which could occur in a non-biological systems (computers, AI, cosmological objects) regardless of of the actual underlying physical substrate?
• Does the way we understand consciousness influence our actions, moral systems, philosophy, politics?
• Does it influence the way we distinguish between human beings and animals and by extension, the way we distinguish between man and nature?

Another aspect of this planned series of essays about consciousness is to have a look at the panorama of contemporary theories about consciousness, such as books by Sir Roger Roger Penrose “The shadows of the mind”, Daniel Dennett Consciousness explained”, the works of Donald Hoffman, David Chalmers, Robert Lawrence Kuhn and many more and to try to get the gist of it.

Conversely, another aim of that series of novels is debunking theories which are purely speculative or simply misleading.

A first aspect of my hypothesis is as follows: The difference between an automaton, or a “philosophical zombie” (in the sense of David Chalmers), on the one hand, and consciousness, on the other hand, is that an automaton is a “system which processes information”, whereas consciousness is (a formal system wherein) “information processes information” (in a recursive, fractal manner).

In other words, a first aspect of my hypothesis is that consciousness is “software running on software”.

To put it another way, this hypothesis postulates that consciousness emerges when a system (a collection of hardware, neurons, etc.) is at the same time the software and the hardware and when said system is capable of producing a self-referential (recursive/fractal) representation of itself), together with the representation (based on sensory input), it builds from the outside world.

To put it yet another way, consciousness is “very deep feedback”, essentially, infinitely deep feedback (fractal-like feedback).

To put it yet another way, consciousness -as such- does not exist; it is more like a placeholder for “consciousness of consciousness of consciousness…” It is a mechanism, a process, not an object.

The fractal nature of consciousness (if my hypothesis has any merit) explains the algebraic/combinatory nature of consciousness:

- a conscious system split in two, results in two consciousnesses (https://youtu.be/0qa_bHMtDcc?si=TVFFvWCJJGIpszy1)

- conversely, a collection of conscious systems connected to each other or exchanging information, results automatically in a higher-order consciousness (like an ant colony or any society, for that matter).

If this hypothesis is correct to some extent , Donald Hoffman’s conjecture about conscious agents is likely both right and wrong. It is correct because conscious agents exist and can be combined into higher-order states of consciousness, but it is wrong in that said conscious agents are purely virtual (not primitives), they exist only within the confines of a self-referential formal system, which has the property of building a representation of itself.

I wouldn’t just reduce consciousness to awareness; I would reduce it further, to a mere potential for awareness (a precursor of awareness , a prerequisite of sorts). I agree that consciousness is often mistaken for higher-order manifestations of the mind, such as memory, cognition, or emotions.

To put it another way: awareness of consciousness is a mechanism, but consciousness itself might not be one. From that point of view, materialism and idealism might just be pointless semantics, meaningless categories. On the other hand, if we can only ever experience awareness of thought processes — awareness of consciousness — then perhaps consciousness is just a construct of the mind: an extrapolation, a virtual, perhaps even imaginary, construct.

[Ref 1] Fractals structures in the brain:

https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3059969/