I’ve been wanting to do this for a long time, and I finally got around to it. I set up a sample site using a Bootstrap 5.3 template. It may not be the most visually striking design, but it does what it’s supposed to do - and it works well. All it took was a bit of custom ASP/VBScript in QS to get the navigation up and running.
I’ve never really understood why Bootstrap never introduced its own CMS. Mobirise did, but it never quite made sense as a CMS. Other platforms offer Bootstrap-based templates, but a dedicated CMS built entirely around Bootstrap’s layout system—its components, forms, utilities, and helpers—could have been a genuinely strong alternative to WordPress.
Even though Jstemplates.com does not spit out very modern nor good looking websites, it's still a fun project.
I recently fixed the Google Web Font integration. Jstemplates are still 100% compatible with QuickerSite and can help to get a website up and running in no time.
Unlike many other block based CMS solutions nowadays, the QS & JStemplates tandem is a powerful toolset to setup dynamic, fast and secure websites in no time. Even though they'll sure have a nineties look. But hey, that's called vintage these days. And vintage is COOL!! ![]()
Update: JStemplates just got even more fun! I added a CSS transition effect.
Building a WordPress website can feel like staring at a giant box of LEGOs without the instruction manual. But beneath the surface, WordPress follows a surprisingly simple logic. Here is the "Big Picture" of how a WordPress website actually works.
1. Content: Posts vs. Pages
WordPress is about Posts and Pages. Think of Posts as the "news" of your site. They’re timely, tagged by category, and usually show up in a feed (like a blog). Pages, on the other hand, are the "timeless" pillars—the "About Us" or "Contact" sections that stay put and don't care about dates. Finally, there are media files: images, videos and most popular filetypes. You can upload them using the Media-manager.
2. The Blueprint: Templates
You don't have to design every post/page from scratch. Templates act as the skeleton, defining where the header, main content, and footer live. WordPress automatically applies these blueprints so your site stays consistent. You can swap a template at any time, though most beginners let the defaults do the heavy lifting!
3. The Building Blocks: Blocks & Patterns
In modern WordPress, everything is a Block. Whether you’re adding a paragraph, a stunning cover image, or a complex layout of columns, you’re using blocks. Sometimes blocks are bundled into "Patterns" - pre-designed layouts (like a hero section) that you can drop in with one click.
The Block Editor is the engine behind modern WordPress. Some blocks are intentionally simple, with just a handful of settings - like paragraphs, where you can adjust spacing, colors, and alignment. Other blocks are far more powerful. A great example is the Cover block, which combines layout, background, and content into a single flexible component, offering many options to experiment with and fine-tune your design.
4. The "Everything is Everywhere" Confusion
Since blocks are used to build both content (Posts/Pages) and the structure (Templates), things can get a little meta. For example, the Blog Home is actually a template that acts like a page. It’s the one spot where the lines blur, but once you realize it's just a template showing a list of blocks, it all clicks.
5. The Aesthetics: Themes
If templates are the skeleton, the Theme is the skin. Your theme provides the overall design, setting the "vibe" for your typography, colors, and spacing. You don't have a template without a theme; they are a package deal that ensures your blocks look stylish right out of the box.
6. The Superpowers: Plugins
Want a shop? A contact form? Better Google rankings? Plugins are the apps of the WordPress world. They extend what your site can do, turning a simple blog into a powerhouse of functionality. You can browse thousands of options on the official WordPress Plugin Directory.
That’s it! Once you understand how these six pieces fit together, you’ve mastered the architecture of WordPress.
There's something deeply satisfying about building websites on your own machine—no server logins, no database hiccups, no frantic midnight security patches. For years, I've been quietly obsessed with desktop-based Static Site Generators (SSGs), those unsung heroes of the web development world.
My journey started in the most '90s way possible: with Microsoft FrontPage. Remember that? Drag, drop, publish. Pure magic for a youngster who just wanted to get something online. Even now, I'll occasionally fire up tools like Mobirise or Nicepage when I need something quick and visual. But recently, I stumbled onto something that's rekindled that old fascination: Publii.
What makes Publii different?
Publii sits in an interesting sweet spot. It's desktop software - meaning everything happens on your computer - but it generates modern, static HTML/CSS/JS websites that load fast and stay secure. No PHP vulnerabilities, no database to corrupt, no server-side complexity.
What strikes me most is how feature-complete it is out of the box. While many SSGs require you to cobble together plugins and configurations, Publii comes loaded:
The interface borrows heavily from WordPress's familiar posts-and-pages structure, which means the learning curve is surprisingly gentle. You're not wrestling with YAML files or memorizing arcane commands - you're just writing and publishing.
The freedom to host anywhere
Here's where Publii really shines: deployment flexibility. Whether you want to push to GitHub Pages, upload via FTP, deploy to Netlify, or manually transfer files, it's all built in. No terminal commands, no deployment scripts, no DevOps degree required.
This might seem like a small thing, but it's actually profound. You're not locked into a platform. You're not paying monthly hosting fees for dynamic features you don't need. Your site is just files - portable, fast, and yours.
Why this still matters
In an era of site builders and managed WordPress hosts, desktop SSGs feel almost rebellious. They're a reminder that websites don't have to be complicated. Sometimes the best solution is the one you can understand completely, the one that runs on your machine, the one that gives you files you can actually touch.
My FrontPage days are long behind me, but that same spark - the joy of creating something and putting it online - hasn't faded. Tools like Publii keep it alive, just with better code and fewer nested table layouts.
If you've never tried a desktop SSG, maybe it's time. Your inner '90s webmaster might thank you.
OpenCode.ai has rapidly become one of the most starred and discussed repositories on GitHub, recently surpassing 43,000 stars. Its popularity stems from a shift in developer preference toward tools that offer more control, privacy, and flexibility than proprietary alternatives like Google Gemini or Claude AI.
Why Developers are Switching to OpenCode?
The software’s meteoric growth - reaching over 400,000 monthly users within months of its launch - is driven by several key technical and philosophical advantages:
Provider Agnosticism: Unlike most AI assistants locked into a single ecosystem (like OpenAI or Anthropic), OpenCode supports over 75 different LLM providers. You can use Claude 3.5 Sonnet, GPT-4o, Gemini 2.0, or even local models (via Ollama) if you want to keep your code entirely offline.
Built for the Terminal (TUI): It features a highly polished, responsive Terminal User Interface. For developers who live in their terminal (especially Neovim or Tmux users), OpenCode feels like a native extension of their workflow rather than a separate app.
Out-of-the-Box LSP Support: It integrates with the Language Server Protocol (LSP). This means it automatically understands your project's structure, "go-to-definition" logic, and type definitions without you having to manually feed it context.
"Plan" vs. "Build" Modes: OpenCode includes a specific Plan Mode that acts as a read-only researcher. It analyzes the codebase and proposes a solution before you switch to Build Mode to let it execute changes, giving developers a safety check before code is modified.
Comparison: OpenCode vs. Proprietary Agents
| Feature | OpenCode.ai | GitHub Copilot / Claude Code |
| Source Code | 100% Open Source (MIT) | Proprietary |
| Model Choice | 75+ (Claude, GPT, Gemini, Local) | Locked to specific models |
| Privacy | Zero data retention; stays local | Data often processed/stored by provider |
| Integration | Terminal, IDE, and GitHub Actions | Primarily IDE-based |
| Pricing | Free (Bring your own API key) | Monthly subscription |
GitHub-Native Automation
A major reason for its GitHub-specific popularity is its deep integration with the platform’s ecosystem. Developers use OpenCode as a GitHub Action to automate project management:
Triage via Comments: You can comment /oc explain this issue on a GitHub issue, and the agent will analyze the thread and provide a summary.
Automated PRs: By typing /oc fix this, OpenCode can automatically create a new branch, write the code to fix a bug, and submit a Pull Request.
Code Review: It can be scheduled to run on every PR to check for quality, security vulnerabilities, or consistency with existing patterns.
Security & Privacy
In an era where enterprises are wary of "AI leakage," OpenCode’s architecture is a significant draw. It stores no code or context data on its own servers. All processing happens either on your local machine or via direct, encrypted API calls to the provider you choose. This has led to its adoption by security-sensitive organizations like Cloudflare.
OpenCode: The Best AI Coding Agent?
This video provides a deep dive into how OpenCode works in a real-world terminal environment and why it is often preferred over Claude AI.