DEV Community: Vic Shóstak

DeepSeek Raises $7.4B — Valuation Could Hit $74B

Vic Shóstak — Thu, 27 Aug 2026 14:17:36 +0000

DeepSeek, a Chinese AI startup, announced a new fundraising round worth $7.4 billion to fuel research, development, and computational infrastructure expansion. According to The Wall Street Journal, this round could push the company's valuation up to $74 billion.

"In early June, DeepSeek attracted a record $7 billion at a $50 billion valuation, with participation from Tencent, CATL, and the National Artificial Intelligence Industry Investment Fund," the press reports.

These funds will accelerate the rollout of new AI models, expand cloud services, and support the company's upcoming Shanghai IPO, likely slated for next year.

Why It Matters

From my perspective, this massive capital injection signals growing investor confidence in domestic AI capabilities. The AI market is heating up globally, and DeepSeek's trajectory shows that Chinese startups are no longer playing catch-up — they are setting the pace.

Russian enterprises should keep a close eye on partnership opportunities with DeepSeek. Leveraging cutting-edge technology from companies like this could be a game-changer for businesses looking to integrate AI at scale.

The combination of a $74B valuation target and an imminent IPO suggests that DeepSeek is not just building technology — it is building an ecosystem. For engineers and founders alike, this is a signal worth paying attention to.

...and I'd like to remind you that if you need to design, build, and launch an AI solution for business automation or personal use, feel free to reach out to me: https://t.me/koddr 😎

💡 Found this useful? Subscribe to me on all platforms so you don't miss new posts 👉 Telegram, VK, TenChat, Dzen, Dev.to or vc.ru

✨ So... real tests of the local Qwen 3.8 27B model

Vic Shóstak — Tue, 25 Aug 2026 17:49:00 +0000

I came across an interesting discussion in several AI-related communities about this Reddit post: one user decided to test how the local Qwen 3.8 27B model behaves in two different agent shells — PI Agent and OpenCode.

From his observations, PI Agent delivers higher-quality results, uses fewer tokens, runs faster and more stably, and most importantly — it doesn’t have a hard 32k output limit.

What impressed me most was context compression: in OpenCode it starts kicking in at around 67k (with a total context window of 100k), while in PI Agent the model “holds up” until 90k, even if you set output to 64k and above.

For those who want to reproduce this locally — even an RTX 3090 is enough, plus a small fine-tune of the model itself (you can find that in the original post).

At the same time, one of the commenters already staged a “duel” between local Qwen paired with PI Agent and Claude Code. The results were very close, and after a small refinement, the PI version even slightly outperformed Claude.

☝️ The main takeaway: with the same model, final quality depends heavily on the “wrapper” — the environment, context engineering, planning mode, overall agent-system setup, and so on...

That’s exactly what I’ve been saying for a long time across all my platforms — without a skilled AI engineer and a properly built agent system, nothing will work well out of the box. Sad but true.

And yes, DM me if you need AI solutions tailored to your tasks 😎

ai #aiagents #qwen

💬 Found this useful? Follow me on all platforms so you don’t miss new posts 👉 Telegram, VK, TenChat, Dzen, Teletype, or vc.ru

⚡️ xAI is rolling out Grok Build — an open-source terminal AI agent written in Rust

Vic Shóstak — Fri, 21 Aug 2026 13:12:02 +0000

Here’s how it works: first it builds a plan, then it can launch up to eight sub-agents in parallel in separate Git worktrees.

✨ The tool works both in interactive mode and in headless mode for CI/CD. And under the hood, the Grok model gives it up to 500,000 tokens of context and a focus on long-running agent tasks.

It’s now also available on the web and in mobile apps: just describe a game, website, or dashboard — and the AI will assemble a prototype that you can then publish on grok.me, push to GitHub, or keep refining via API.

Yep, this is Elon Musk’s answer to Claude Code and Codex — that’s right 😉

Let’s see how Grok Build performs on real-world tasks, but what’s happening in this market right now is exciting. The race among AI giants for our subscriptions continues!

☝️ But it’s important to remember: even the newest/coolest/most popular vibe-coding tools and agent systems don’t work 100% on their own.

Like in all of IT, without strong AI engineers and a well-designed agent system, they quickly start just “eating tokens” without delivering much value for a specific project task or for the business as a whole.

...so if you need to design and launch an agent system to automate your business processes or for personal use, feel free to DM me 😌

ai #aiagents #grok #xai

💬 Like the way I write? Follow me on all platforms so you don’t miss new posts 👉 Telegram, VK, TenChat, Dzen, Teletype, or vc.ru

🤖 I Built 2 Telegram Bots with Qwen3.8-Max — and the Results Were Seriously Impressive

Vic Shóstak — Sun, 16 Aug 2026 18:20:52 +0000

💬 Following up on the story about the release of Qwen3.8-Max, I finally tried it on real-world tasks.

Specifically, for building AI consultants for text channels (messengers) in my favorite programming language — Go.

Spoiler: it’s really good, especially for such a low price per 1M tokens! 😍

As a result, I built 2 demo Telegram bots, where GPT-4.1-mini acts as the brains 👇

1️⃣ A bot for qualifying a customer and booking a car repair appointment, which asks for details about the vehicle and the issue, answers questions about service pricing, and schedules a convenient visit time.

2️⃣ A bot for calculating kitchen pricing for furniture companies, which уточняет kitchen parameters through guiding questions, calculates the cost, sends the final estimate, and books the client at the company office for a detailed design session.

Before implementation, of course, I wrote a detailed spec for each of these bots and connected MCP Context7.

I also had to make 1–2 corrective prompts for code style and some business-logic details... but otherwise, Qwen3.8-Max worked fully autonomously in the engineering loop (questioning itself at every stage and adjusting its own reasoning and code).

Token usage (input + output) totaled ~12.8 million, across about 400 API requests to the Chinese model. That’s seriously impressive! For comparison, I ran the same task through DeepSeek V4 Flash Latest: with similar output results, it used over 15 million tokens.

By the way, the whole development process was done in the next-gen AI IDE Kodik, by our local guys — ArchiTech AI.

Highly recommend downloading and trying it. Not an Ad! I’ve been using it for over a month now, and it’s truly a very high-quality product, especially in the era of account bans from Anthropic and OpenAI 😏

...and soon, a local model called Qwen3.8-27b is also expected to drop, which Alibaba has promised to release any day now... that’s definitely something that can make the big AI model vendors nervous!

😉 And if you need to design, build, and launch an AI solution for you and/or automate your business processes, feel free to DM me: t.me/koddr

💡 Interesting to read? Follow me on all platforms so you don’t miss new posts 👉 Telegram, VK, TenChat, Dzen, Teletype, or vc.ru

🎉 Finally! Official launch of the Gowebly project on ProductHunt

Vic Shóstak — Fri, 19 Jul 2024 12:18:41 +0000

Hello, DEV friends! 😘

I'm pleased to present you the Gowebly project launch page on ProductHunt 👇

Yes, I know that many people have already tried using this CLI in their daily tasks. Therefore, I ask you to take the time and write a small (or large) review on the project page here. This will help me move on and improve Gowebly CLI every day! 😌

And for those who have just heard about Gowebly, here is a short reference 👇

The Gowebly CLI performs the same function as create-react-app (or similar) to start a new project without wasting time. Also, this project serves as a guide to the world of full-stack development on Go using the htmx library, hyperscript or Alpine.js.

Thank you for staying with me! 🔥 Together we can do more.

– Vic Shóstak aka @koddr

⚡️ Gowebly CLI now supports the PocketBase framework

Vic Shóstak — Fri, 10 May 2024 08:12:25 +0000

Introduction

Hello, DEV people! 👋

Now, I've released the Gowebly CLI v2.5.0 which includes PocketBase framework/backend support.

Okay, let's get started 😉

📝 Table of contents

What is PocketBase?
How to use PocketBase with Gowebly CLI?

What is PocketBase?

PocketBase is an open source ready-to-use framework/backend for your next SaaS and mobile application in a single file.

pocketbase / pocketbase

Open Source realtime backend in 1 file

PocketBase is an open source Go backend that includes:

embedded database (SQLite) with realtime subscriptions
built-in files and users management
convenient Admin dashboard UI
and simple REST-ish API

For documentation and examples, please visit https://pocketbase.io/docs.

Warning

Please keep in mind that PocketBase is still under active development and therefore full backward compatibility is not guaranteed before reaching v1.0.0.

API SDK clients

The easiest way to interact with the PocketBase Web APIs is to use one of the official SDK clients:

JavaScript - pocketbase/js-sdk (Browser, Node.js, React Native)
Dart - pocketbase/dart-sdk (Web, Mobile, Desktop, CLI)

You could also check the recommendations in https://pocketbase.io/docs/how-to-use/.

Overview

Use as standalone app

You could download the prebuilt executable for your platform from the Releases page. Once downloaded, extract the archive and run ./pocketbase serve in the extracted directory.

The prebuilt executables are based on the examples/base/main.go…

View on GitHub

Main features:

Realtime database. Embedded performant database with schema builder, data validations, realtime subscriptions and easy to use REST api.
Authentication. Manage your app users and handle email/password and OAuth2 sign-ups (Google, Facebook, GitHub, GitLab and more) without the hassle.
File storage. Sanely store files locally or in a S3 storage. Easily attach media to your database records and generate thumbs on the fly.
Extendable. Use as a standalone app OR as a framework, that you can extend via Go and JavaScript hooks to create your own custom portable backend.

↑ Table of contents

How to use PocketBase with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v2.5.0 or higher.

Next, when you start creating a new project, just switch the Go framework selector to the PocketBase option:

gowebly create

And Gowebly CLI created a new project with the PocketBase.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
PocketBase authors https://pocketbase.io

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

Preline UI + Gowebly CLI = ❤️

Vic Shóstak — Thu, 25 Apr 2024 14:13:20 +0000

Introduction

Hey, DEV friends! 👋

Today, I've released the Gowebly CLI v2.4.0 which includes Preline UI components library support for the frontend.

Yep, let's take a closer look 👇

📝 Table of contents

What is Preline UI?
How to use Preline UI with Gowebly CLI?

What is Preline UI?

Preline UI is an open-source set of prebuilt UI components based on the utility-first Tailwind CSS framework.

htmlstreamofficial / preline

Preline UI is an open-source set of prebuilt UI components based on the utility-first Tailwind CSS framework.

Preline UI is an open-source Tailwind CSS UI component library for building modern websites and apps. It includes UI blocks, templates, plugins, a Figma design system, and more.

✨ About Preline

Preline helps teams build modern websites and web apps faster with reusable Tailwind CSS components, interactive headless Tailwind CSS plugins, Tailwind CSS templates, and production-ready Tailwind CSS examples. It is designed for developers who want flexible markup, scalable design systems, and polished UI patterns without rebuilding everything from scratch.

⚡ Getting Started

Start with any working Tailwind CSS project and make sure Node.js and npm are installed.

Install via npm

Install preline:

npm i preline

Import the Preline CSS variants file into your Tailwind CSS file after…

View on GitHub

Most awesome features:

750+ Free Components & Examples. Hundreds of component examples for all your website needs that meet accessibility criteria.
Universal Framework Compatibility. Preline UI is fully compatible wherever Tailwind CSS is in action, from React to Vue and beyond.
Tailwind CSS Plugins. Completely unstyled, fully accessible UI plugins for popular features that for one reason or another don't belong in core.
Dark Mode. All components include a dark variant that lets you style your site differently when dark mode is enabled.
World's largest free Figma design system. Preline UI Figma is the largest free design system for Figma, crafted with Tailwind CSS styles and Preline UI components with extra top-notch additions.
Bring your ideas to life in no time. Preline UI provides all the essential components you need to convert your vision into thriving start-ups.

↑ Table of contents

How to use Preline UI with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v2.4.0 or higher.

Next, when you start creating a new project, just switch the CSS framework selector to the Tailwind CSS with Preline UI components option:

gowebly create

And Gowebly CLI created a new project with the Preline UI.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
Preline UI authors https://preline.co

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🤓 My top 3 Go packages that I wish I'd known about earlier

Vic Shóstak — Fri, 01 Mar 2024 11:36:24 +0000

Introduction

Hello, my DEV friends! 🙌

Today, I'd like to travel back in time, find myself at the very beginning of planning my current project, and advise myself to familiarize myself with these wonderful Go packages…

Unfortunately, I can't do that! But I can introduce you to them. Here we go 👇

📝 Table of contents

Templ
Otter
River

Templ

a-h / templ

A language for writing HTML user interfaces in Go.

A language for writing HTML UI in Go

✨ In recent months, I have been developing web projects using GOTTHA stack: Go + Templ + Tailwind CSS + htmx + Alpine.js. As soon as I'm ready to talk about all the subtleties and pitfalls, I'll post it on my social networks.

By the way, you can subscribe! All links are here 👉 https://shostak.dev

Perhaps my favorite Go package in my entire practice of working with this programming language! The authors managed to combine two huge worlds at once:

The world of the frontend, which consists almost entirely of JSX-like web frameworks, such as React.js;
The world of the backend, where we are free to use our familiar Go principles and packages as usual.

Together with Templ we can write the following code:

// index.templ

package main

templ hello(name string) {
    if name == "Виктор" {
        <div>Привет, Виктор! Как твои дела сегодня?</div>
    } else {
        <div>Hello, { name }</div>
    }
}

templ greeting(person Person) {
    <div class="greeting">
        @hello(person.Name)
    </div>
}

// ...

Next, you just need to start the process of generating all *.templ files:

go run github.com/a-h/templ/cmd/templ@latest generate

Which will be converted into a regular Go function and ready for use on your backend. For example, like this:

// main.go

package main

// ...

// Simple user struct.
type Person struct {
    Name string
}

func main() {
    // Create a new user with name.
    user := Person{Name: "John"}

    // Create Templ handler.
    handler := templ.Handler(greeting(user))

    // Serve Templ handler with HTTP server.
    http.Handle("/", handler)

    // Start simple HTTP server.
    http.ListenAndServe(":3000", nil)
}

Open browser on http://localhost:3000 and see the result.

Yes, it's that simple! 😉

🔥 Templ authors have taken care of supporting popular IDE and special mode for hot-reload your *.templ files.

If you have never tried Templ in your code practice, then I strongly recommend doing it right now! It's really worth it.

↑ Table of contents

Otter

maypok86 / otter

A high performance caching library for Go

High performance in-memory cache

I believe that the most important features of Otter are extremely simple API and autoconfiguration. And it works perfectly!

Just set the parameters you want in the builder and enjoy. Otter is automatically configured based on the parallelism of your application.

Just write like this to create a new cache instance:

// cache/new.go

package cache

// ...

// Cache struct contains all caches.
type Cache struct {
    People otter.CacheWithVariableTTL[string, []Person]
}

func New() (*Cache, error) {
    // Create a new cache instance for people.
    peopleCache, err := otter.MustBuilder[string, []Person](100_000).WithVariableTTL().Build()
    if err != nil {
        return nil, err
    }

    return &Cache{
        People: peopleCache,
    }, nil
}

And now, you can use it on your app, like this:

// main.go

// ...

func main() {
    // ...

    // Get people from database.
    people, err := dbexecutor.SelectPeople(context.Background(), "postgres://...", "SELECT * FROM people")
    if err != nil {
        slog.Error("can't select people from DB", "details", err.Error())
        return err
    }

    // Create a new cache instance.
    c, _ := cache.New() // don't forget to check errors!

    // Save people to the cache with TTL=180m.
    if c.People.Set("people", people, 180 * time.Minute) {
        slog.Info("people are successfully saved to the in-memory cache")
    }

    // ...

    // Get people from the cache.
    cachedPeople, isCached := c.People.Get("people")

    // Check, if data is cached.
    if isCached {
        // Your logic with cached data in cachedPeople here...
    }

    // ...
}

I would also like to point out such advantages as:

Generics: yes, you can safely use any comparable types as keys and any types as values;
TTL: expired values will be automatically deleted from the cache;
Cost-based eviction: supports eviction based on the cost of each item;
Excellent throughput: currently, Otter is the fastest cache library, with a huge lead over the competition;
Great hit ratio: new S3-FIFO algorithm is used, which shows excellent results.

And benchmark, of course! 😊

In this benchmark 8 threads concurrently read from a cache configured with a maximum size:

👋 You can find all benchmarks here.

↑ Table of contents

River

riverqueue / river

Fast and reliable background jobs in Go

I'm a big fan of all the new stuff that the Go programmer community is developing. River is one of them.

It represents a combination of modern Go practices and ease of use, even if you have never worked with similar tools before.

🔥 Atomic, transaction-safe, robust job queueing for Go applications. Backed by PostgreSQL and built to scale.

And yet, this package has one of the best documentation on the market. Just read how the authors describe writing of reliable workers' principle! Love it 😘

Start with add a simple job that sorts a slice of strings:

// jobs/sort.go

package jobs

// ...

// sortArgs is a struct that contains a slice of strings to sort.
type sortArgs struct {
    // Strings is a slice of strings to sort.
    Strings []string `json:"strings"`
}

// Kind returns the kind of the job.
func (sortArgs) Kind() string { return "sort" }

// SortWorker is a worker that sorts a slice of strings.
type SortWorker struct {
    river.WorkerDefaults[sortArgs]
}

// Work sorts a slice of strings.
func (w *SortWorker) Work(_ context.Context, job *river.Job[sortArgs]) error {
    slices.Sort(job.Args.Strings)
    fmt.Printf("Sorted strings: %+v\n", job.Args.Strings)
    return nil
}

// ...

Next, let's create a new River queue with workers pool:

// queue/new.go

package queue

// ...

func pool() (*river.Workers, error) {
    // Create a new River instance.
    w := river.NewWorkers()

    // Add workers to River.
    _ = river.AddWorkerSafely(w, &jobs.SortWorker{}) // don't forget to check errors!

    return w, nil
}

func New() (*river.Client[pgx.Tx], error) {
    // Create workers pool.
    workers, _ := pool() // don't forget to check errors!

    // Create and return a new River client
    // (for PostgreSQL over pgx/v5, by the way).
    return river.NewClient(riverpgxv5.New(db), &river.Config{
        Queues: map[string]river.QueueConfig{
            river.QueueDefault: {MaxWorkers: 100},
        },
        Workers: workers,
    })
}

And now, you can use it on your app, like this:

// main.go

// ...

func main() {
    // ...

    // Create a sample data to sort.
    str := []string{"foo", "baz", "bar"}

    // Create a new River instance.
    q, _ := queue.New() // don't forget to check errors!

    // Set job to queue.
    _, err := q.Insert(context.Background(), jobs.SortArgs{Strings: str}, nil)
    if err != nil {
        slog.Error("can't insert job to River queue", "details", err.Error())
    }

    // ...
}

That's all you have to do! 💥 You can create arbitrarily complex background jobs that River can easily complete for you.

💡 River is still under rapid development, but I recommend trying it now!

↑ Table of contents

And what do you use?

Tell us about it in the comments! It will be very interesting to find new Go packages and tools for yourself.

Peace to all and a successful code! ❤️

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🎉 The Gowebly CLI has grown to v2.0.0

Vic Shóstak — Thu, 11 Jan 2024 07:45:29 +0000

Introduction

Happy New Year, my DEV friends! 🎊

While everyone was relaxing and thinking about Christmas, I was hard at work in my studio to prepare a massive update for the Gowebly CLI number v2.

I don't like to drag out the intro, so here we go! 😉

📝 Table of contents

What is Gowebly?
Breaking changes
Live reload mode on code updates
Other notable improvements

What is Gowebly?

A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx & hyperscript and the most popular CSS frameworks on the frontend.

gowebly / gowebly

🔥 A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js, and the most popular CSS frameworks on the frontend.

The Gowebly CLI

A next-generation CLI tool that makes it easy to create amazing web applications
with Go on the backend, using htmx, hyperscript or Alpine.js,
and the most popular CSS frameworks on the frontend.

↘ The official Gowebly CLI documentation ↙

English · Русский · 简体中文 · Español

↘ Share the project's link to your friends ↙

✨ Features

100% free and open source under the Apache 2.0 license.
For any developer's level of knowledge and technical expertise, as the intelligent CLI does most of the routine project setup for you, creates an understandable structure, and prepares code for use and deployment in production.
Cross-platform and multi-architecture allows successful running on any GNU/Linux distros, Microsoft Windows (including WSL) and Apple macOS.
Well-documented, includes translations in many other languages (Русский, 简体中文, Español).
Enables you to start a new project faster with Go…

View on GitHub

↑ Table of contents

Breaking changes

After gathering the opinion of the most active users and based on the experience of my other successful CLI project Create Go App, I decided to remove the possibility of configuring with a YAML file.

✨ Yes, .gowebly.yml is no longer needed!

The handy and incredibly beautiful huh library from the Charm team is now in charge of that. Just upgrade to the latest version of the Gowebly and type the familiar command in the terminal:

gowebly create

And just look at this:

The same thing happened with the unknown and the doctor commands, which now look (and feel) completely different:

gowebly doctor

↑ Table of contents

Live reload mode on code updates

It was highly anticipated, and I decided not to delay and make it as soon as possible. Since version v2.0.0, the Gowebly CLI supports reloading a project running in development mode if changes are made to it:

Go code;
Templ or HTML templates;
SASS/CSS styles;
TypeScript/JavaScript files;
Frontend part settings (JSON).

This is made possible thanks to the Air tool, which now comes with every project you create. The configuration is as follows:

# .air.toml

root = "."
tmp_dir = "tmp"

[build]
pre_cmd = ["bun run build"]
cmd = "templ generate && go build -o ./tmp/gowebly_default ."
bin = "tmp/gowebly_default"
include_ext = ["go", "templ", "html", "json", "js", "ts", "css", "scss"]
exclude_dir = [".parcel-cache", "bin", "dist", "node_modules", "static", "tmp", "tests", "vendor"]
exclude_regex = ["_test\\.go", "_templ\\.go"]
exclude_unchanged = false
follow_symlink = false
log = "build-errors-air.log"
poll = false
poll_interval = 500
delay = 1000
stop_on_error = true
send_interrupt = false
kill_delay = 500
rerun = false
rerun_delay = 500

# ...

If you don't want to use Air, when creating a new project, select "No" when the CLI prompts you to use the tool. In this case, this Makefile will be created.

↑ Table of contents

Other notable improvements

The backend has been completely reimagined:

Repetitive elements in templates have been removed;
The configs for creating a Docker container have been simplified;
Add the htmx-go package to simplify the htmx handling at the server layer of the application.

The frontend part has received the following refresh:

Repetitive elements in templates have been removed;
Add a ./assets/scripts.js file for your reactive logic;
Add the Flowbite components library for the Tailwind CSS;
Add the Prettier for code formatting.

And not only that! 😊 Keep an eye out for updates and new releases on the project's GitHub page and official documentation.

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Big frontend update: the Gowebly CLI now supports Bootstrap and Bulma

Vic Shóstak — Tue, 19 Dec 2023 11:17:51 +0000

Introduction

Hey, DEV friends! 😉

Since v1.9.0 release, the Gowebly CLI includes support for Bootstrap and Bulma CSS frameworks.

Let's take a closer look.

📝 Table of contents

What is Bootstrap?
What is Bulma?
How to use new CSS frameworks with Gowebly CLI?

What is Bootstrap?

Powerful, extensible, and feature-packed frontend toolkit. Build and customize with Sass, utilize prebuilt grid system and components, and bring projects to life with powerful JavaScript plugins.

twbs / bootstrap

The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web.

↑ Table of contents

What is Bulma?

The modern CSS framework that just works. Free & open source framework that provides ready-to-use frontend components that you can easily combine to build responsive web interfaces. No CSS knowledge required.

jgthms / bulma

Modern CSS framework based on Flexbox

↑ Table of contents

How to use new CSS frameworks with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.9.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
  module_name: project
  go_framework: default
  template_engine: default
  port: 7000
  timeout:
    read: 5
    write: 10

frontend:
  package_name: project
  css_framework: default
  runtime_environment: default
  htmx: latest
  hyperscript: latest

Now, just switch the css_framework option in the frontend block to bootstrap or bulma.

Now, start creating a project:

gowebly create

And Gowebly CLI create a new project with the selected CSS framework.

It works! 💥

↑ Table of contents

Photos and videos by

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Frontend update: the Gowebly CLI now supports daisyUI components library

Vic Shóstak — Tue, 21 Nov 2023 11:50:35 +0000

Introduction

Hello, DEV Community! 😉

I've released the Gowebly v1.8.0 which includes daisyUI components library support for the frontend.

But let's not get ahead of ourselves, let's take a closer look.

📝 Table of contents

What is daisyUI?
How to use daisyUI with Gowebly CLI?

What is daisyUI?

daisyUI is the most popular, free and open-source component library for Tailwind CSS. This library adds component class names to Tailwind CSS, so you can make beautiful websites faster than ever.

saadeghi / daisyui

🌼 🌼 🌼 🌼 🌼 The most popular, free and open-source Tailwind CSS component library

Take Tailwind CSS to the next level

daisyUI adds class names to Tailwind CSS for all common UI components, like btn, card, toggle and many more. This allows us to focus on important things instead of styling basic elements for every project.

Instead of writing 100 class names...

Use semantic class names! It's descriptive, faster, cleaner and easier to maintain.

No more ugly HTML

Write fewer class names, use component class names, modify them using Tailwind CSS utilities. For example, daisyUI can convert this HTML code:

<div class="w-80 rounded-2xl bg-gray-100">
  <div class="flex flex-col gap-2 p-8">
    <input placeholder="Email" class="w-full rounded-lg border border-gray-300 bg-white px-4 py-3 focus:outline-none focus:ring-2 focus:ring-gray-700 focus:ring-offset-2 focus:ring-offset-gray-100" />
    <label class="flex cursor-pointer items-center justify-between p-1">
      Accept terms of use
      <div class="relative inline-block">
        <input type="checkbox" class="peer h-6 w-12 cursor-pointer appearance-none rounded-full border border-gray-300 bg-white checked:border-gray-900 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-900 focus-visible:ring-offset-2" />
        <span class="pointer-events-none absolute start-1 top-1 block h-4 w-4 rounded-full bg-gray-400 transition-all duration-200 peer-checked:start-7 peer-checked:bg-gray-900"></span>
      </div>
    </label>
    <label class="flex cursor-pointer items-center justify-between p-1">
      Submit to newsletter
      <div class="relative inline-block">
        <input type="checkbox" class="peer h-6 w-12 cursor-pointer appearance-none rounded-full border border-gray-300 bg-white checked:border-gray-900 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-900 focus-visible:ring-offset-2" />
        <span class="pointer-events-none absolute start-1 top-1 block h-4 w-4 rounded-full bg-gray-400 transition-all duration-200 peer-checked:start-7 peer-checked:bg-gray-900"></span>
      </div>
    </label>
    <button class="inline-block cursor-pointer rounded-md bg-gray-700 px-4 py-3.5 text-center text-sm font-semibold uppercase text-white transition duration-200 ease-in-out hover:bg-gray-800 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-700 focus-visible:ring-offset-2 active:scale-95">Save</button>
  </div>
</div>

To this:

<div class="card bg-base-200 w-80">
  <div class="card-body">
    <input placeholder="Email" class="input input-bordered" />
    <label class="label cursor-pointer">
      Accept terms of use
      <input type="checkbox" class="toggle" />
    </label>
    <label class="label cursor-pointer">
      Submit to newsletter
      <input type="checkbox" class="toggle" />
    </label>
    <button class="btn btn-neutral">Save</button>
  </div>
</div>

Fewer class names, faster development, smaller file size

With daisyUI, you write 80% fewer class names and your HTML size will be about 70% smaller.

Highly customizable

Powered by Tailwind CSS utility classes. daisyUI is built on top of Tailwind CSS, so you can customize everything using utility classes.

Pure CSS, framework-agnostic, works everywhere!

daisyUI is a plugin for Tailwind CSS. It works on all JS frameworks and doesn't need a JS bundle file. Install daisyUI as a dev dependency and use the class names just like any other Tailwind CSS class name.

↑ Table of contents

How to use daisyUI with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.8.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
  module_name: project
  go_framework: default
  template_engine: default
  port: 7000
  timeout:
    read: 5
    write: 10

frontend:
  package_name: project
  css_framework: default
  runtime_environment: default
  hyperscript: latest

Yes, you're right! ✨ Just switch the css_framework option in the frontend block to daisyui.

Now, start creating a project:

gowebly create

And Gowebly CLI created a new project with the daisyUI.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
daisyUI authors https://daisyui.com

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Big update: the Gowebly CLI now supports Templ

Vic Shóstak — Wed, 01 Nov 2023 11:39:41 +0000

Introduction

Hello, everyone! 🙌

I've released a big update to the Gowebly CLI project in v1.5.0 which includes Templ support for built-in net/http and all Go web frameworks: Fiber, go-chi and echo.

But let's not get ahead of ourselves, let's take a closer look.

📝 Table of contents

What is Templ?
How to use Templ with Gowebly CLI?
Templates content
Backend handler changes

What is Templ?

Templ is a language for writing HTML user interfaces in Go.

a-h / templ

A language for writing HTML user interfaces in Go.

You can use it to write code like this, which will be compiled into native Go functions to generate HTML:

// hello.templ

package main

templ Hello(name string) {
  <div>Hello, { name }</div>
}

templ Greeting(person Person) {
  <div class="greeting">
    @Hello(person.Name)
  </div>
}

💡 Note: A complete user guide is here: https://templ.guide/

Create components that render fragments of HTML and compose them to create screens, pages, documents, or apps.

TOP features:

Server-side rendering: Deploy as a serverless function, Docker container, or standard Go program.
Static rendering: Create static HTML files to deploy however you choose.
Compiled code: Components are compiled into performant Go code.
Use Go: Call any Go code, and use standard if, switch, and for statements.
No JavaScript: Does not require any client or server-side JavaScript.
Great developer experience: Ships with IDE autocompletion.

Yes, Templ has plugins for most popular IDEs:

Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=a-h.templ
VSCodium: https://open-vsx.org/extension/a-h/templ
Vim / Neovim: https://github.com/Joe-Davidson1802/templ.vim
Helix: https://helix-editor.com/

💡 Note: Settings and useful tips you can read here.

↑ Table of contents

How to use Templ with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.5.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
   module_name: project # (string) option can be any name of your Go module (for example, 'github.com/user/project')
   go_framework: default # (string) option can be one of the values: 'fiber', 'echo', 'chi', or 'default'
   template_engine: default # (string) option can be one of the values: 'templ', or 'default'
   port: 5000 # (int) option can be any port that is not taken up on your system
   timeout:
      read: 5 # (int) option can be any number of seconds, 5 is recommended
      write: 10 # (int) option can be any number of seconds, 10 is recommended

frontend:
   package_name: project # (string) option can be any name of your package.json (for example, 'project')
   css_framework: default # (string) option can be one of the values: 'tailwindcss', 'unocss', or 'default'
   runtime_environment: default # (string) option can be one of the values: 'bun', or 'default'
   htmx: latest # (string) option can be any existing version
   hyperscript: latest # (string) option can be any existing version

Yes, you're right! ✨ There is a new option template_engine in the backend block, which can take (so far) two values:

default to create a new project without a template engine;
templ to create a new project using Templ;

Now, change the value of this setting to templ and start creating a project:

gowebly create

And CLI created a new project with the following structure:

.
├── assets
│   └── styles.css
├── static
│   ├── favicons
│   │   ├── apple-touch-icon.png
│   │   ├── favicon.ico
│   │   ├── favicon.png
│   │   ├── favicon.svg
│   │   ├── manifest-desktop-screenshot.jpeg
│   │   ├── manifest-mobile-screenshot.jpeg
│   │   └── manifest-touch-icon.svg
│   ├── images
│   │   └── logo.svg
│   ├── htmx.min.js
│   ├── hyperscript.min.js
│   ├── manifest.json
│   └── styles.css
├── templates
│   ├── pages
-   │   ├── index.html
+   │   ├── index.templ
+   │   └── index_templ.go
-   ├── main.html
+   ├── main.templ
+   └── main_templ.go
├── go.mod
├── go.sum
├── handlers.go
├── main.go
├── package-lock.json
├── package.json
└── server.go

Files with the extension *.templ are our working files, and those with *_templ.go in the name are automatically generated for us with Templ.

❗️ Attention: Do not edit the *_templ.go Go files in any way. They will be generated automatically. Work only with *.templ files.

↑ Table of contents

Templates content

Okay, now let's take a look at the template files.

The ./templates/main.templ template contains the basic layout for the web application and can be modified as you wish:

// ./templates/main.templ

package templates

import "project/templates/pages"

// Define a secure policy for Content-Security-Policy header.
var metaContentSecurePolicy = "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' https://unpkg.com 'unsafe-inline' 'unsafe-eval';"

templ Layout(title string, metaTags, bodyContent templ.Component) {
    <!DOCTYPE html>
    <html lang="en">
        <head>
            <meta charset="UTF-8"/>
            <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
            <meta http-equiv="X-UA-Compatible" content="ie=edge"/>
            <meta http-equiv="Content-Security-Policy" content={ metaContentSecurePolicy }/>
            <meta name="theme-color" content="#FEFEF5"/>
            <title>{ title }</title>
            {! metaTags }
            <link rel="manifest" href="/static/manifest.json"/>
            <link rel="apple-touch-icon" href="/static/favicons/apple-touch-icon.png"/>
            <link rel="shortcut icon" href="/static/favicons/favicon.ico" type="image/x-icon"/>
            <link rel="icon" href="/static/favicons/favicon.svg" type="image/svg+xml"/>
            <link rel="icon" href="/static/favicons/favicon.png" sizes="any"/>
            <link href="/static/styles.css" rel="stylesheet"/>
        </head>
        <body onload={ pages.BodyScripts() }>
            {! bodyContent }
            <script src="/static/htmx.min.js"></script>
            <script src="/static/hyperscript.min.js"></script>
        </body>
    </html>
}

And the ./templates/pages/index.templ template will contain the content of the home page (accessible at /):

// ./templates/pages/index.templ

package pages

// MetaTags defines meta tags.

templ MetaTags(keywords, description string) {
    <meta name="keywords" content={ keywords }/>
    <meta name="description" content={ description }/>
}

// styledTextStyles defines CSS styles for component.

css styledTextStyles() {
    color: blue;
    margin: 1rem 0;
}

// BodyContent defines HTML content.

templ BodyContent(h1, text string) {
    <main>
        <div>
            <p>
                <img width="224px" src="/static/images/logo.svg" alt="logo"/>
            </p>
            <div>
                <h1>{ h1 }</h1>
                <p>{ text }</p>
                <p class={ styledTextStyles() }>
                    Hello from <strong>templ</strong>!
                    <br/>
                    Edit this styled text in the './templates/pages/index.templ' file.
                </p>
                <p>
                    <a href="https://gowebly.org" target="_blank">Documentation</a>,
                    <a href="https://github.com/gowebly/gowebly" target="_blank">GitHub</a>
                </p>
            </div>
            <div>
                <p><button hx-get="/api/show" hx-target="#htmx-result">Show content</button></p>
                <div id="htmx-result"></div>
            </div>
        </div>
    </main>
}

// BodyScripts defines JavaScript code.

script BodyScripts() {
    console.log("Hello from templ!", "Edit this JavaScript code in the './templates/pages/index.templ' file.");
}

The code in the templates is as readable and easy to understand as possible for any developer who has ever made sites in HTML and understands Go.

↑ Table of contents

Backend handler changes

If it is clear with the templates themselves, here are the changes that handlers.go has undergone:

// handlers.go

// ...

// indexViewHandler handles a view for the index page.
func indexViewHandler(w http.ResponseWriter, r *http.Request) {
    // Check, if the current URL is '/'.
    if r.URL.Path != "/" {
        // If not, return HTTP 404 error.
        http.NotFound(w, r)
        slog.Error("render page", "method", r.Method, "status", http.StatusNotFound, "path", r.URL.Path)
        return
    }

    // Define template functions.
    metaTags := pages.MetaTags(
        "gowebly, htmx example page, go with htmx",               // define meta keywords
        "Welcome to example! You're here because it worked out.", // define meta description
    )
    bodyContent := pages.BodyContent(
        "Welcome to example!",                // define h1 text
        "You're here because it worked out.", // define p text
    )

    // Define template layout.
    if err := templates.Layout(
        "Welcome to example!", // define title text
        metaTags, bodyContent,
    ).Render(r.Context(), w); err != nil {
        // Send HTTP 500 error with log.
        w.WriteHeader(http.StatusInternalServerError)
        slog.Error("render template", "method", r.Method, "status", http.StatusInternalServerError, "path", r.URL.Path)
        return
    }

    // Send log message.
    slog.Info("render page", "method", r.Method, "status", http.StatusOK, "path", r.URL.Path)
}

// ...

The templates.Layout() Go function is the Templ function from the ./templates/main.templ template, which was kindly generated automatically when the project was created.

💡 Note: The Gowebly CLI knows that your project contains a Templ templer and will generate code from the *.templ templates every time it changes (hot-reload).

Let's run your project:

gowebly run

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
Templ authors https://github.com/a-h/templ

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.