DEV Community: M

Pushing wireguard-go from 3.5 Gbps to 5 Gbps: A battle against the Go GC on old CPU 🚀

Mon, 13 Apr 2026 10:56:34 +0000

Hey DEV community! 👋

I’ve been on a mission to push standard wireguard-go to its absolute limits. I was sitting at a respectable 3.5 Gbps on my old CPU, but I wanted that magic 5 Gbps number.

Here is how I squeezed out that last 1.5 Gbps and hit my goal:

Slaying the Allocation Dragon 🐉
At millions of packets per second, Go's Garbage Collector is your biggest enemy. I used an LLM as an "escape analysis copilot" to hunt down heap allocations on the hot path. We dropped the alloc/op from 72 down to exactly 1.
Stack > Heap 📚
To keep the GC asleep, variables cannot escape to the heap. We swapped the standard crypto/curve25519 for Cloudflare's circl/dh/x25519 (which uses fixed-size, stack-friendly arrays) and rewrote constructors to modify variables in-place (CreateMessageInitiationInto) instead of returning pointers.
The "Duh" Moment 🤦‍♂️
After all that complex crypto optimization, I gained an instant 200+ Mbps just by completely disabling verbose debug logs. Even with fast checks, hidden mutex locks and I/O syscalls are silent performance killers. This got me to 4.5 Gbps.
Clearing the Runway ✈️
The final push to a flat 5.0 Gbps? Realizing the CPU was dealing with background noise. When your code is this highly optimized, your bottleneck is the CPU scheduler. Killing background processes and giving the Go app a clear runway unlocked the final 500 Mbps.

The Takeaway:
You can write ultra-fast networking gear in pure Go, but you have to treat the Garbage Collector like an enemy on the hot path.

performance report: https://github.com/blinkinglight/wireguard-go/blob/performance/PERF_REPORT.md
branch if you want to test it: performance ( https://github.com/blinkinglight/wireguard-go/blob/performance )

_ p.s. LLM is used to translate article _

wgmesh - new way to build wireguard mesh networks

Sat, 11 Apr 2026 08:17:02 +0000

hey,
we just want to introduce FOSS wgmesh tool to build wireguard mesh networks. It uses dht for peer discovery and just works. You can read more in https://wgmesh.dev

golang + sse + Data-Star for real time progress bar

Thu, 27 Mar 2025 10:29:29 +0000

Hello everyone,

somtimes happens, that one request could block whole page for minutes with heavy on demand job. And thats not good. But with data-star its very simple to give user realtime feedback about whats happenining.

here is tiny code example:

r.Post("/progress", func(w http.ResponseWriter, r *http.Request) {
        sse := datastar.NewSSE(w, r)
        progress := 0
        total := 10124
        processed := 0
        for {
            select {
            case <-r.Context().Done():
                return
            default:
                processed++
                progress = (processed * 100 / total)
                // lets say here is our heavy job function which is slow but after each step we notify user with progress
                time.Sleep(1 * time.Millisecond)
                 // send updates to frontend via SSE 
                sse.MergeFragmentTempl(Progress(fmt.Sprintf("%d", processed), fmt.Sprintf("%d", total), fmt.Sprintf("%d", progress)))
                if progress == 100 {
                    sse.MergeFragmentTempl(Done())
                    return
                }
            }
        }
    })

whats nice about DataStar and SSE that each GET PUT POST PATCH DELETE requests could respond N events stream in realtime while doing heavy work, so user always can see progress of whats happening.

heres full working code repo: https://github.com/blinkinglight/go-progressbar

golang + sse + Data-Star for real time sys stats

Mon, 24 Mar 2025 07:16:05 +0000

Hello everyone,
today I want to show you, how simple with https://data-star.dev hypermedia framework to is to make real time "things"

lets start with some code.

tools we need today is:
https://templ.guide for html templating
https://data-star.dev for realtime frontend updates via SSE
https://github.com/inhies/go-bytesize to convert bytes to normal representation like Mb Gb
https://github.com/shirou/gopsutil to get sys stats
and https://github.com/go-chi/chi for routing

first, we need to collect sys stats (memory and cpu) so there is our helper function:

type Stats struct {
    MemTotal   string
    MemPercent float64
    MemUsed    string
    MemFree    string
    SwapTotal  string
    CpuUser        int
    CpuSystem      int
    CpuIdle        int
}

func collectStats() Stats {
    v, _ := mem.VirtualMemory()
    cp, _ := cpu.Times(false)
    var stats Stats
    stats.MemUsed = bytesize.New(float64(v.Used)).String()
    stats.MemTotal = bytesize.New(float64(v.Total)).String()
    stats.MemFree = bytesize.New(float64(v.Free)).String()
    stats.MemPercent = v.UsedPercent

    for _, c := range cp {
        stats.CpuSystem += int(c.System)
        stats.CpuUser += int(c.User)
        stats.CpuIdle += int(c.Idle)
    }

    stats.CpuSystem /= len(cp)
    stats.CpuUser /= len(cp)
    stats.CpuIdle /= len(cp)
    return stats
}

now once we have our stats we could implement our realtime updates. here is some main code for it:

r.Get("/live/stats", func(w http.ResponseWriter, r *http.Request) {
        sse := datastar.NewSSE(w, r)
        ticker := time.NewTicker(1 * time.Second)
        defer ticker.Stop()
        for {
            select {
            case <-r.Context().Done():
                return
            case <-ticker.C:
                stats := collectStats()
                sse.MergeFragmentTempl(Stat(stats))
            }
        }
    })

this collects stats every one second, and publishes it to Data-Star via SSE

and our index page renders everything at initial load:

r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        stats := collectStats()
        Main(stats).Render(r.Context(), w)
    })

Main(statS) is main layout with doctype and all partials like "stats" section. In piece of code for /live/stats - it renders only part of page and sends that part as html to data-star which updates stats element. (not whole page are send)

and here is our templ.guide template:


templ Main(stats Stats) {
    <!DOCTYPE html>
    <html>
        <head>
            <title>Sys Stats</title>
            <script type="module" src="https://cdn.jsdelivr.net/gh/starfederation/datastar@v1.0.0-beta.9/bundles/datastar.js"></script>
        </head>
        <body data-on-load="@get('/live/stats')"></body>
        @Stat(stats)
    </html>
}

templ Stat(stats Stats) {
    <div id="stats">
    <p><strong>MemFree</strong> { fmt.Sprintf("%s", stats.MemFree) }</p>
    <p><strong>MemUsed</strong> { fmt.Sprintf("%s",stats.MemUsed) }</p>
    <p><strong>MemTotal</strong> { fmt.Sprintf("%s",stats.MemTotal) }</p>
    <p><strong>MemPercent</strong> { fmt.Sprintf("%f",stats.MemPercent) }</p>
    <p><strong>CPU system</strong> { fmt.Sprintf("%d",stats.CpuSystem) }</p>
    <p><strong>CPU user</strong> { fmt.Sprintf("%d",stats.CpuUser) }</p>
    <p><strong>CPU idle</strong> { fmt.Sprintf("%d",stats.CpuIdle) }</p>
    </div>
}

templ Main - accepts stats as argument, renders whole html and subscribes for changes on /live/stats url.

templ Stat - accepts stats as argument, renders only that part and will be sent to SSE (idiomorph finds element with same id and replaces it )

example could be found at https://github.com/blinkinglight/go-sysstats clone, run go run . and navigate to https://localhost:8088 and it should just work.

tailscale and beszel on hashicorp nomad

Tue, 21 Jan 2025 18:22:23 +0000

hey,
i just want it to share with you what i found today: https://tailscale.com/blog/video-beszel

so i deciced to try it on hashicorp nomad and it works great!

here is jobs example:

beszel dashboard

variables {
  domain = "beszel.my.domain.tld"
}

job "beszel-dashboard" {
  datacenters = ["rpi"]

  group "beszel" {
    count = 1

    task "beszel-dashboard" {
      driver = "docker"

      config {
        image = "henrygd/beszel:latest"

        extra_hosts = [
          "host.docker.internal:host-gateway"
        ]
        volumes = [
          "/data/beszel:/beszel_data",
        ]
      }

      resources {
        cpu    = 500
        memory = 1024
      }

      service {
        name = "beszel-dashboard"
        provider     = "nomad"
        address_mode = "driver"
        port = "8090"
        tags = [
          "traefik.enable=true",
          "traefik.http.routers.http-${NOMAD_ALLOC_ID}.entrypoints=web",
          "traefik.http.routers.http-${NOMAD_ALLOC_ID}.rule=Host(`${var.domain}`)",
          "traefik.http.services.http-${NOMAD_ALLOC_ID}.loadbalancer.server.port=8090",
          # "traefik.http.services.https-${NOMAD_ALLOC_ID}.loadbalancer.server.port=8090",
          "traefik.http.routers.https-${NOMAD_ALLOC_ID}.rule=Host(`${var.domain}`)",
          "traefik.http.routers.https-${NOMAD_ALLOC_ID}.entrypoints=websecure",
          "traefik.http.routers.https-${NOMAD_ALLOC_ID}.tls.certresolver=le",
          "traefik.http.routers.https-${NOMAD_ALLOC_ID}.tls=true"
        ]
      }
    }
  }
}

and system job for agents:

job "beszel-agent" {
  datacenters = ["*"]
  type        = "system"

  meta {
    version = "2"
  }


  group "beszel" {
    count = 1

    network {
      mode = "host"
      port "http" {
        host_network = "tailscale"
        static       = 45876
      }
    }

    task "beszel-agent" {
      driver = "docker"

      config {
        image        = "henrygd/beszel-agent:latest"
        volumes      = ["/var/run/docker.sock:/var/run/docker.sock:ro"]
        ports        = ["http"]
      }
      env {
        PORT = "45876"
        KEY  = "<your key from dashboard here>"
      }
    }
  }
}

each new host gets its own agent on port, so you can add that IP to your beszel dashboard.

and thats it.

new way thinking. python + data-star

Sat, 19 Oct 2024 17:52:05 +0000

Tiny example in python what https://data-star.dev does.

Realtime clock example in python:

from flask import Flask, Response
import time

app = Flask(__name__)

def get_time():
    return '<div id="time">{}</div>'.format(time.strftime('%H:%M:%S'))

@app.route('/')
def index():
    return """
    <!DOCTYPE html>
    <html>
        <head>
            <script type="module" defer src="https://cdn.jsdelivr.net/npm/@sudodevnull/datastar"></script>
        </head>
        <body>
            <div data-on-load="$$get('/events')">
               <h1>Clock</h1>
                {}    
            </div>
        </body>
    </html>
    """.format(get_time())

@app.route('/events')
def events():
    def generate():
        while True:
            yield 'event: datastar-fragment\n'
            yield 'data:  fragment {}\n\n'.format(get_time())
            time.sleep(1)

    return Response(generate(), content_type='text/event-stream')

if __name__ == '__main__':
    app.run(debug=True)

realtime chat with bot using data-star

Thu, 17 Oct 2024 15:32:59 +0000

Hello everyone,

in part 1 i made simple server side clock https://dev.to/blinkinglight/golang-data-star-1o53/

and now decided to write more complex things using https://nats.io and https://data-star.dev -

Chat bot which returns what you wrote to it:

some golang code:

package handlers

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    "github.com/blinkinglight/chat-data-star/web/views/chatview"
    "github.com/delaneyj/datastar"
    "github.com/delaneyj/toolbelt"
    "github.com/delaneyj/toolbelt/embeddednats"
    "github.com/go-chi/chi/v5"
    "github.com/gorilla/sessions"
    "github.com/nats-io/nats.go"
)

func SetupChat(router chi.Router, session sessions.Store, ns *embeddednats.Server) error {

    type Message struct {
        Message string `json:"message"`
        Sender  string `json:"sender"`
    }

    nc, err := ns.Client()
    if err != nil {
        return err
    }

    nc.Subscribe("chat.>", func(msg *nats.Msg) {
        var message = Message{}
        err := json.Unmarshal(msg.Data, &message)
        if err != nil {
            log.Printf("%v", err)
            return
        }

        if message.Sender != "bot" {
            // do something with user message and send back response
            nc.Publish("chat."+message.Sender, []byte(`{"message":"hello, i am bot. You send me: `+message.Message+`", "sender":"bot"}`))
        }
    })

    _ = nc
    chatIndex := func(w http.ResponseWriter, r *http.Request) {
        _, err := upsertSessionID(session, r, w)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        chatview.Index().Render(r.Context(), w)
    }

    chatMessage := func(w http.ResponseWriter, r *http.Request) {
        id, err := upsertSessionID(session, r, w)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        var state = Message{}

        err = datastar.BodyUnmarshal(r, &state)
        if err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }

        state.Sender = id
        b, err := json.Marshal(state)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        nc.Publish("chat."+id, b)
        sse := datastar.NewSSE(w, r)
        _ = sse
    }

    chatMessages := func(w http.ResponseWriter, r *http.Request) {

        id, err := upsertSessionID(session, r, w)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        var ch = make(chan *nats.Msg)
        sub, err := nc.Subscribe("chat."+id, func(msg *nats.Msg) {
            ch <- msg
        })

        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        defer close(ch)
        defer sub.Unsubscribe()

        sse := datastar.NewSSE(w, r)

        for {
            select {
            case <-r.Context().Done():
                return

            case msg := <-ch:
                var message = Message{}
                err := json.Unmarshal(msg.Data, &message)
                if err != nil {
                    datastar.Error(sse, err)
                    return
                }
                if message.Sender == "bot" {
                    datastar.RenderFragmentTempl(sse, chatview.Bot(message.Message), datastar.WithMergeAppend(), datastar.WithQuerySelector("#chatbox"))
                } else {
                    datastar.RenderFragmentTempl(sse, chatview.Me(message.Message), datastar.WithMergeAppend(), datastar.WithQuerySelector("#chatbox"))
                }
            }
        }
    }

    router.Get("/chat", chatIndex)
    router.Post("/chat", chatMessage)
    router.Get("/messages", chatMessages)

    return nil
}

func upsertSessionID(store sessions.Store, r *http.Request, w http.ResponseWriter) (string, error) {

    sess, err := store.Get(r, "chatters")
    if err != nil {
        return "", fmt.Errorf("failed to get session: %w", err)
    }
    id, ok := sess.Values["id"].(string)
    if !ok {
        id = toolbelt.NextEncodedID()
        sess.Values["id"] = id
        if err := sess.Save(r, w); err != nil {
            return "", fmt.Errorf("failed to save session: %w", err)
        }
    }
    return id, nil
}

and template

package chatview

import "github.com/blinkinglight/chat-data-star/web/views/layoutview"

templ Index() {
    @layoutview.Main() {
        <!-- component -->
        <div class="fixed bottom-0 right-0 mb-4 mr-4">
            <button id="open-chat" class="bg-blue-500 text-white py-2 px-4 rounded-md hover:bg-blue-600 transition duration-300 flex items-center">
                <svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6 mr-2" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6"></path>
                </svg>
                Chat with Admin Bot
            </button>
        </div>
        <div id="chat-container" class="hidden fixed bottom-16 right-4 w-96">
            <div class="bg-white shadow-md rounded-lg max-w-lg w-full">
                <div class="p-4 border-b bg-blue-500 text-white rounded-t-lg flex justify-between items-center">
                    <p class="text-lg font-semibold">Admin Bot</p>
                    <button id="close-chat" class="text-gray-300 hover:text-gray-400 focus:outline-none focus:text-gray-400">
                        <svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
                        </svg>
                    </button>
                </div>
                <div id="chatbox" class="p-4 h-80 overflow-y-auto" data-on-load="$$get('/messages')" data-store="{ message: '' }">
                    <!-- Chat messages will be displayed here -->
                </div>
                <div class="p-4 border-t flex">
                    <input data-model="message" id="user-input" type="text" placeholder="Type a message" class="w-full px-3 py-2 border rounded-l-md focus:outline-none focus:ring-2 focus:ring-blue-500"/>
                    <button data-on-keydown.window.key_enter="$$post('/chat'); $message=''" data-on-click="$$post('/chat'); $message=''" id="send-button" class="bg-blue-500 text-white px-4 py-2 rounded-r-md hover:bg-blue-600 transition duration-300">Send</button>
                </div>
            </div>
        </div>
        <script>
        const chatbox = document.getElementById("chatbox");
                const chatContainer = document.getElementById("chat-container");
                const userInput = document.getElementById("user-input");
                const sendButton = document.getElementById("send-button");
                const openChatButton = document.getElementById("open-chat");
                const closeChatButton = document.getElementById("close-chat");

                let isChatboxOpen = true; // Set the initial state to open

                function toggleChatbox() {
                    chatContainer.classList.toggle("hidden");
                    isChatboxOpen = !isChatboxOpen; // Toggle the state
                }

                openChatButton.addEventListener("click", toggleChatbox);

                closeChatButton.addEventListener("click", toggleChatbox);
                toggleChatbox();

        </script>
    }
}

templ Me(message string) {
    <div class="mb-2 text-right">
        <p class="bg-blue-500 text-white rounded-lg py-2 px-4 inline-block">{ message }</p>
    </div>
}

templ Bot(message string) {
    <div class="mb-2">
        <p class="bg-gray-200 text-gray-700 rounded-lg py-2 px-4 inline-block">{ message }</p>
    </div>
}

you can find working example at https://github.com/blinkinglight/chat-data-star

realtime web with data-star

Sat, 12 Oct 2024 15:13:55 +0000

Here is tiny example of how simple and clean "live" things can be in golang using https://data-star.dev

The server clock:

cmd/app/main.go

package main

import (
    "log"
    "net/http"

    "github.com/blinkinglight/clock-data-star/handlers"
    "github.com/go-chi/chi/v5"
)

func main() {
    router := chi.NewRouter()

    handlers.SetupHome(router)

    log.Printf("Starting server on :3000")
    log.Fatal(http.ListenAndServe(":3000", router))
}

handlers/handlers.go

package handlers

import (
    "net/http"
    "time"

    "github.com/blinkinglight/clock-data-star/web/views"
    "github.com/delaneyj/datastar"
    "github.com/go-chi/chi/v5"
)

func SetupHome(router chi.Router) {

    homeRoute := func(w http.ResponseWriter, r *http.Request) {
        views.ClockPage().Render(r.Context(), w)
    }

    clockRoute := func(w http.ResponseWriter, r *http.Request) {
        sse := datastar.NewSSE(w, r)
        ticker := time.NewTicker(time.Second)
        for {
            select {
            case <-r.Context().Done():
                ticker.Stop()
                return
            case <-ticker.C:
                datastar.RenderFragmentTempl(sse, views.ClockFragment(time.Now().Format("15:04:05")))
            }
        }
    }

    router.Get("/", homeRoute)
    router.Get("/clock", clockRoute)
}

web/views/page.templ

package views

templ Page() {
    <!DOCTYPE html>
    <html>
        <head>
            <script type="module" defer src="https://cdn.jsdelivr.net/npm/@sudodevnull/datastar"></script>
        </head>
        <body>
            <div>
                { children... }
            </div>
        </body>
    </html>
}

and web/views/clock.templ

package views

import "github.com/delaneyj/datastar"

templ ClockPage() {
    @Page() {
        <div data-on-load={ datastar.GET("/clock") }>
            <h1>Clock</h1>
                        @ClockFragment(time.Now().Format("15:04:05"))
        </div>
    }
}

templ ClockFragment(t string) {
    <div id="clock">
        { t }
    </div>
}

and thats it.

working example lives here: https://github.com/blinkinglight/clock-data-star

This should be everyones dream

Mon, 23 Sep 2024 21:31:27 +0000

check this out https://data-star.dev/

go htmx and sse example

Tue, 27 Aug 2024 16:56:43 +0000

This example demonstrates how to replace few blocks on event for example "post with id 1 changed" ( post-1-changed ) and trigger to load content via ajax request on "chatter" event.

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/r3labs/sse/v2"
)

func main() {
    server := sse.New()
    _ = server.CreateStream("messages")

    mux := http.NewServeMux()
    mux.HandleFunc("/events", func(w http.ResponseWriter, r *http.Request) {

        // la security
        token := r.URL.Query().Get("token")
        if token != "secret" {
            http.Error(w, "invalid token", http.StatusUnauthorized)
            return
        }
        go func() {
            <-r.Context().Done()
            println("The client is disconnected here")
            return
        }()

        server.ServeHTTP(w, r)
    })

    mux.HandleFunc("/chatroom", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`<div>Hello from chat room</div>`))
    })

    mux.HandleFunc("/index", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`
        <html>
        <head>
        <script src="https://unpkg.com/htmx.org@2.0.2/dist/htmx.js"></script>
        <script src="https://unpkg.com/htmx-ext-sse@2.2.2/sse.js"></script>
        </head>
        <body hx-ext="sse" sse-connect="/events?stream=messages&token=secret">
        <div >
            <div sse-swap="post-1-changed">one</div>
        </div>
        <div>
            <div sse-swap="post-1-changed">one</div>
        </div>
        <div>
            <div sse-swap="post-1-changed">one</div>
        </div>
        <div>
            <div sse-swap="notifications">one</div>
        </div>
        <div>
            <div hx-get="/chatroom" hx-trigger="sse:chatter">
                chat body reloaded
            </div>
        </div>
        </body></html>
        `))
    })

    go func() {
        i := 0
        for {
            i++
            time.Sleep(1 * time.Second)

            server.TryPublish("messages", &sse.Event{
                ID:    []byte(fmt.Sprintf("%d", i)),
                Event: []byte("post-1-changed"),
                Data:  []byte(`<div>Hello from sse ` + fmt.Sprintf("%d", i) + `</div>`),
            })

            server.TryPublish("messages", &sse.Event{
                ID:    []byte(fmt.Sprintf("%d", i)),
                Event: []byte("notifications"),
                Data:  []byte(`<div>Hello from post 2 sse ` + fmt.Sprintf("%d", i) + `</div>`),
            })

            server.TryPublish("messages", &sse.Event{
                ID:    []byte(fmt.Sprintf("%d", i)),
                Event: []byte("chatter"),
                Data:  []byte(`<div></div>`),
            })
            server.EventTTL = 5 * time.Second
        }
    }()

    http.ListenAndServe(":9999", mux)
}

Trying to get into laravel dependency injection

Sun, 11 Aug 2024 15:36:53 +0000

<?php

use App\Models\User;

test('Action', function () {

    app()->singleton(ClassInterface::class, T1Impl::class);
    $out1 = app(ClassInterface::class)();
    $this->assertEquals("T1?", $out1);

    app()->bind(ClassInterface::class, T2Impl::class);

    $out2 = app(ClassInterface::class)();
    $this->assertEquals("T2!", $out2);

    app()->bind(T1Impl::class, T2Impl::class);
    $out3 = app(T1Impl::class)();
    $this->assertEquals("T2!", $out3);



    app()->bind(T2Impl::class, T3Impl::class);
    app()->bind(T1Impl::class, T2Impl::class);
    app()->singleton(ClassInterface::class, T1Impl::class);
    $out4 = app(ClassInterface::class)();
    $this->assertEquals("T3!", $out4);


    $user = User::factory()->create(['name'=>'Tomas']);
    $out5 = app(T4::class, ['user'=>$user])();
    $this->assertEquals("Tomas", $out5);
});

interface ClassInterface {
    public function __invoke();
}

class T1Impl implements ClassInterface {
    public function __invoke() {
        return "T1?";
    }
}

class T2Impl implements ClassInterface {
    public function __invoke() {
        return "T2!";
    }
}


class T3Impl implements ClassInterface {
    public function __invoke() {
        return "T3!";
    }
}

class T4 {
    public function __construct(
        public User $user
    ){}

    public function __invoke() {
        return $this->user->name;
    }
}

And.. That means if I will do laravel "right", it lets me to drop "nwidard/larave-modules" Module and its overrides any part of code ?

Laravel service class

Tue, 06 Aug 2024 10:30:32 +0000