Lunatic is a WebAssembly runtime inspired by Erlang. It provides isolated, lightweight processes for massive concurrency and fault tolerance. Easily create distributed clusters with secure connections between nodes.

Dart FFI bindings for the box3d 3D rigid body physics engine. Changelog excerpt: - Initial release. These bindings are in active development; this release reserves the package name and establishes the package structure. FFI bindings and native binaries are not yet included.

How much does a Rust Developer in Web3 make? The average yearly salary of a Rust Developer in Web3 is $150k per year, with a minimum base salary of $80k and a maximum of $275k

Explore the latest features of Rust 1.96, including innovative copy-friendly range types that simplify coding and improve performance for developers. The post Rust 1.96 Introduces New Copy-Friendly Range Types appeared first on Linux Today.

If you've ever opened a .mp4 inside VS Code, you may have noticed something weird: the video plays,...

Comments

Uncover the details of LibreOffice's outlined strategy for web and mobile, focusing on enhanced features and user accessibility. Get the latest insights now. The post LibreOffice Outlines New Web and Mobile Strategy appeared first on Linux Today.

Contribute to zaneenders/shape-tree development by creating an account on GitHub.

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, C#, JavaScript, TypeScript, Lua and Python with on-the-fly Wasm compilation. Changelog excerpt: ### Wasm backend: rich-enum field/method reads in a `print`context - Fixed garbage values when a rich-enum instance field or method result was passed through `print(...)`/ string interpolation (e.g. `print(p.gravity)`or `print('${p.mult(2)}')`). The lazily-generated enum-entry initializer baked its constructor `call`index during an early discovery pass, before the `print`/`double_to_str`host imports were registered; those imports then shifted every function index, so the cached call landed on a[...]

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, C#, JavaScript, TypeScript, Lua and Python with on-the-fly Wasm compilation. Changelog excerpt: ### Wasm backend: rich-enum field/method reads in a `print`context - Fixed garbage values when a rich-enum instance field or method result was passed through `print(...)`/ string interpolation (e.g. `print(p.gravity)`or `print('${p.mult(2)}')`). The lazily-generated enum-entry initializer baked its constructor `call`index during an early discovery pass, before the `print`/`double_to_str`host imports were registered; those imports then shifted every function index, so the cached call landed on a[...]

A pure-Rust SCSS to CSS compiler (a dart-sass alternative). Zero dependencies, wasm-friendly, lib + CLI. - momiji-rs/sasso

Learn to decompile GameCube PowerPC assembly into byte-matching C, graded live by the real MWCC GC/2.0 compiler.

Native LiteRT-LM bindings for Flutter across mobile, desktop, and web.

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, C#, JavaScript, TypeScript, Lua and Python with on-the-fly Wasm compilation. Changelog excerpt: ### Wasm backend: rich-enum field/method reads in a `print`context - Fixed garbage values when a rich-enum instance field or method result was passed through `print(...)`/ string interpolation (e.g. `print(p.gravity)`or `print('${p.mult(2)}')`). The lazily-generated enum-entry initializer baked its constructor `call`index during an early discovery pass, before the `print`/`double_to_str`host imports were registered; those imports then shifted every function index, so the cached call landed on a[...]

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, C#, JavaScript, TypeScript, Lua and Python with on-the-fly Wasm compilation. Changelog excerpt: ### Rich enums (enum entries are `const`class instances) - Enums are redesigned: an enum is a class and each entry is a cached `const`instance — a singleton, so `==`is identity — replacing the int-ordinal model. Every entry carries `index`(ordinal) and `name`, and `EnumName.values`lists them. **Dart enhanced enums**work: entries with constructor arguments, fields, and methods (`Planet.earth.gravity()`). Explicit-value entries (C#/TypeScript `Medium = 5`) expose the value via `.value`. - Parsing[...]

Cruzo — минималистичный UI-фреймворк без лишней сложности Знакомимся с Cruzo. Часть 1. RxBucket – контейнер состояний и конфигураций компонентов на фронте Я продолжаю серию обзорных статей о...

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, C#, JavaScript, TypeScript, Lua and Python with on-the-fly Wasm compilation. Changelog excerpt: ### Language: C# — lambda parsing - Parse C# lambda expressions (`x => x * 2`, `(a, b) => a + b`, `(int a) => { ... }`, `() => 0`); previously C# could only *generate*lambda syntax, not read it. - Delegate type names (`Func`, `Action`, `Delegate`, `Function`) map to the shared function type, so a lambda value binds to a delegate-typed parameter. ### Control flow: `switch`/`case`, `break`, `continue`, `do`/`while` - New shared AST/runtime nodes (`ASTStatementBreak`, `ASTStatementContinue`, `AS[...]

ApolloVM, a Multilingual portable VM (native, JS/Web, Flutter) for Dart, Java, Kotlin, JavaScript, Lua with on-the-fly Wasm compilation. Changelog excerpt: - Wasm Asyncify: **awaits inside control flow**(`if`/`if-else`/`else if`, `while`, `for`), plus `return await ...`and `x = await ...`. The generator lowers such async functions into a CFG of basic blocks and emits a program-counter state machine — a `loop`+ `br_table`dispatch over a `$pc`local, with `$pc`spilled/restored on the Asyncify frame stack alongside the locals. Awaits become block boundaries; leaf (host) and internal (module- async) awaits both work inside loops/branches, composing wit[...]

本文永久链接 - https://tonybai.com/2026/06/26/policy-for-removing-godebug-flags 大家好，我是Tony Bai。 2012 年 3 月，Go 1.0 的发布确立了那条被奉为开源界圣经的规则——Go 1 兼容性保证（Go 1 compatibil

JavaScript is often misunderstood, with many referring to it as a scripting language without fully understanding the implications or the characteristics that define such languages. The question of whether JavaScript is a scripting language is complex and multifaceted, requiring an exploration of its origins, features, and applications. In this article, we will delve into the world of programming languages, define what scripting languages are, and examine JavaScript’s place within this context. ## Introduction to Scripting Languages Scripting languages are high-level programming languages that are interpreted rather than compiled. This means that the code written in a scripting language is not converted into machine code beforehand but is instead interpreted line by line during execution. **Interpreted languages** are typically easier to learn and faster to develop with, as they do not require the compilation step, allowing for more rapid prototyping and testing. Scripting languages are often used for tasks that require quick development and execution, such as scripting web pages, automating system tasks, or creating interactive user interfaces. ### Characteristics of Scripting Languages To determine if JavaScript is a scripting language, it’s essential to understand the key characteristics of scripting languages: – **Interpreted** : Scripting languages are interpreted, meaning the code is executed line by line without the need for compilation into machine code. – **High-Level** : They are high-level languages, abstracting away many low-level details, making it easier for developers to focus on the logic of the program without worrying about memory management or other low-level tasks. – **Dynamic Typing** : Many scripting languages are dynamically typed, which means the data type of a variable is determined at runtime, not at compile time. – **Rapid Development** : Scripting languages facilitate rapid development and prototyping due to their interpreted nature and high-level abstractions. ### Examples of Scripting Languages Other notable scripting languages include Python, Ruby, and PHP. Each of these languages has its own set of features and is used in different contexts. For example, Python is widely used in data science and machine learning, while Ruby is known for its use in web development with the Ruby on Rails framework. PHP is predominantly used for server-side web development. ## JavaScript: A Closer Look JavaScript, initially named “Mocha,” was created by Brendan Eich in 1995 while he was working at Netscape Communications. It was initially intended for client-side scripting on the web, allowing for the creation of interactive web pages. Over the years, JavaScript has evolved significantly, becoming one of the most popular programming languages in the world, used not only for client-side scripting in web browsers but also for server-side programming with technologies like Node.js, mobile and desktop app development, and even in databases. ### Features of JavaScript JavaScript exhibits many characteristics of scripting languages: – **Interpreted** : JavaScript code is interpreted by web browsers or by runtimes like Node.js, depending on the environment in which it’s executed. – **High-Level** : It abstracts away low-level details, allowing developers to focus on the logic of their applications. – **Dynamic Typing** : JavaScript is dynamically typed, which means the data type of a variable is determined at runtime. – **First-Class Functions** : JavaScript supports first-class functions, which can be passed around like any other variable, making it a very flexible language for programming. ### Applications of JavaScript The versatility of JavaScript is evident in its wide range of applications: – **Web Development** : JavaScript is used for client-side scripting, creating interactive web pages, and developing desktop and mobile applications. – **Server-Side Programming** : With Node.js, JavaScript can be used for server-side programming, allowing developers to run JavaScript on the server. – **Mobile and Desktop Applications** : Frameworks like React Native and Electron enable developers to build mobile and desktop applications using JavaScript. – **Game Development** : JavaScript is used in game development, especially with libraries like Phaser. ## Conclusion: Is JavaScript a Scripting Language? Given its characteristics and applications, **JavaScript does indeed share many traits with traditional scripting languages**. It is interpreted, high-level, dynamically typed, and facilitates rapid development. However, the term “scripting language” often carries connotations of being less powerful or less capable than compiled languages, which is not accurate for JavaScript. JavaScript’s versatility, from web development to server-side programming and beyond, positions it as a full-fledged programming language that happens to be interpreted and dynamically typed, rather than merely a scripting language. ### The Evolution of JavaScript As JavaScript continues to evolve, with advancements in technologies like WebAssembly and the development of new frameworks and libraries, its capabilities and applications are expanding. This evolution underscores JavaScript’s role as a primary programming language for the web and beyond, rather than just a scripting tool. #### Future of JavaScript The future of JavaScript looks promising, with ongoing efforts to improve its performance, security, and usability. As the web and software development landscapes continue to evolve, JavaScript is likely to remain at the forefront, adapting to new challenges and opportunities. Whether classified strictly as a scripting language or not, JavaScript’s impact on the world of programming and its continued growth in popularity are undeniable. In conclusion, while the question of whether JavaScript is a scripting language may seem semantic, understanding its characteristics and applications provides valuable insight into the nature of programming languages and their evolving roles in software development. JavaScript’s unique blend of features and its widespread adoption across different domains make it a fascinating case study in the classification and capabilities of programming languages. ## What is JavaScript and how is it used? JavaScript is a high-level, dynamic, and interpreted programming language that is primarily used for client-side scripting on the web. It allows developers to create interactive web pages, web applications, and mobile applications by adding dynamic effects, animations, and functionality to websites. JavaScript is also used for server-side programming, game development, and mobile app development, making it a versatile and widely-used language. Its syntax is based on the ECMAScript standard, and it is supported by most web browsers, including Google Chrome, Mozilla Firefox, and Microsoft Edge. The use of JavaScript has evolved over the years, and it is now used in a variety of applications, including web development, mobile app development, and server-side programming. JavaScript frameworks like React, Angular, and Vue.js have made it easier to build complex web applications, while libraries like jQuery and Lodash have simplified DOM manipulation and utility functions. Additionally, JavaScript is used in popular frameworks like Node.js, which allows developers to run JavaScript on the server-side, and Electron, which enables developers to build cross-platform desktop applications using web technologies. ## Is JavaScript a scripting language or a programming language? The debate about whether JavaScript is a scripting language or a programming language has been ongoing for years. While some people argue that JavaScript is a scripting language due to its origins as a client-side scripting language for the web, others argue that it is a full-fledged programming language due to its ability to be used for complex applications, including server-side programming, game development, and mobile app development. The term “scripting language” often implies a language that is used for quick, simple tasks, whereas a programming language is often associated with more complex, structured applications. However, the distinction between a scripting language and a programming language is not always clear-cut, and JavaScript blurs the line between the two. JavaScript has many features that are commonly found in programming languages, such as variables, data types, control structures, functions, and object-oriented programming. It also has a large standard library and a wide range of third-party libraries and frameworks that make it suitable for complex applications. Therefore, whether JavaScript is considered a scripting language or a programming language ultimately depends on how it is being used and the context in which it is being applied. ## What are the key features of JavaScript? JavaScript has several key features that make it a popular and versatile language. One of its most notable features is its dynamic nature, which allows developers to add or modify code at runtime. JavaScript is also an interpreted language, which means that code is executed line by line, without the need for compilation. Additionally, JavaScript is a first-class functional language, which means that functions are treated as objects and can be passed as arguments to other functions or returned as values from functions. JavaScript also supports object-oriented programming, which allows developers to create reusable code and organize complex applications. Another key feature of JavaScript is its ability to interact with the Document Object Model (DOM) of a web page, which allows developers to dynamically modify the structure and content of a web page. JavaScript also has a large standard library that includes a wide range of built-in functions and objects, such as arrays, dates, and regular expressions. Furthermore, JavaScript has a vast ecosystem of third-party libraries and frameworks that make it suitable for a wide range of applications, from simple web pages to complex web applications and mobile apps. These features, combined with its versatility and widespread adoption, have made JavaScript one of the most popular programming languages in the world. ## How does JavaScript differ from other programming languages? JavaScript differs from other programming languages in several ways. One of the main differences is its client-side execution model, which allows JavaScript code to run on the client’s web browser, rather than on the server. This allows for faster and more interactive web pages, as well as reduced server load. JavaScript is also a dynamically-typed language, which means that variable types are determined at runtime, rather than at compile time. This makes JavaScript more flexible and easier to use, but also more prone to errors. Additionally, JavaScript has a unique syntax and semantics that are different from other programming languages, such as its use of callbacks and asynchronous programming. Another way in which JavaScript differs from other programming languages is its extensive use of callbacks and event-driven programming. JavaScript’s asynchronous nature allows it to handle multiple tasks concurrently, making it well-suited for real-time web applications and interactive web pages. JavaScript also has a large and active community, with many libraries, frameworks, and tools available to help developers build complex applications. Furthermore, JavaScript is constantly evolving, with new features and standards being added regularly, such as async/await, promises, and classes. These differences, combined with its versatility and widespread adoption, have made JavaScript a unique and powerful programming language. ## What are the advantages of using JavaScript? The advantages of using JavaScript are numerous. One of the main advantages is its versatility, which allows it to be used for a wide range of applications, from simple web pages to complex web applications and mobile apps. JavaScript is also a relatively easy language to learn, especially for developers who are already familiar with other programming languages. Additionally, JavaScript is a client-side language, which means that it can run on the client’s web browser, reducing the load on the server and improving the overall user experience. JavaScript is also a dynamic language, which allows developers to add or modify code at runtime, making it ideal for rapid prototyping and development. Another advantage of using JavaScript is its extensive ecosystem of libraries, frameworks, and tools. There are many popular libraries and frameworks available, such as React, Angular, and Vue.js, which make it easier to build complex web applications. Additionally, JavaScript has a large and active community, with many online resources, tutorials, and forums available to help developers learn and troubleshoot. Furthermore, JavaScript is constantly evolving, with new features and standards being added regularly, which makes it an exciting and dynamic language to work with. Overall, the advantages of using JavaScript make it a popular choice among developers, and its versatility and widespread adoption have made it a fundamental part of the web development landscape. ## What are the common applications of JavaScript? JavaScript is commonly used for a wide range of applications, including web development, mobile app development, and server-side programming. On the client-side, JavaScript is used to create interactive web pages, web applications, and mobile applications by adding dynamic effects, animations, and functionality to websites. JavaScript is also used for desktop and mobile app development, using frameworks like Electron and React Native. Additionally, JavaScript is used for server-side programming, using frameworks like Node.js, which allows developers to run JavaScript on the server-side and create scalable and high-performance server-side applications. JavaScript is also used in other areas, such as game development, using libraries like Phaser, and data visualization, using libraries like D3.js. Furthermore, JavaScript is used in machine learning and artificial intelligence, using libraries like TensorFlow.js, and in Internet of Things (IoT) development, using frameworks like Johnny-Five. The versatility and widespread adoption of JavaScript have made it a fundamental part of the software development landscape, and its applications continue to grow and expand into new areas. Whether it’s used for client-side scripting, server-side programming, or mobile app development, JavaScript is an essential tool for any developer looking to build complex and interactive applications.

I had 300 product photos sitting in a folder. White backgrounds, mostly. I needed them on transparent...

Когда мы начинали работать над проектом, нам очень хотелось сделать интерактивные песочницы для кода — такие, в которых можно быстро проверить JavaScript-сниппет, прогнать SQL-запрос или...

Learn how to create a Scratch game step by step in 2026 with this 12-step tutorial. Build a physics-heavy platformer with sprites, collisions, and sound—no extensions needed.

Welcome to GitHub repos. Here you'll find valuable information on the latest trending projects. Subscribe to stay informed and gain insights from the thriving GitHub community.

Flutter makes it easy and fast to build beautiful apps for mobile and beyond - flutter/flutter

Most "free online file tools" upload your file to a server, do the work there, and send it back. For...

本文永久链接 - https://tonybai.com/2026/06/25/go-1-27-uuid-newv7-always-generates-uuid-with-7000-on-browsers 大家好，我是Tony Bai。 在刚刚发布第一个候选版本（RC1）的 Go 1.27 中，一个让开发者感到贴

The 8-Hour "Please Work" Marathon We’ve all been there. You have a vision. You want to...

Flutter plugin for the exath-engine: a complex-native math evaluator with computer algebra (diff, factor, solve, integral, linear algebra), prebuilt for every platform. Changelog excerpt: - First release of `exath_engine`: a Flutter plugin for the [exath-engine](https://github.com/Fabian2000/exath-engine), a complex-native math evaluator with a computer-algebra core. Prebuilt native libraries are bundled for Android, iOS, macOS, Windows, and Linux, and the WASM module is bundled for web. Call `await ensureInitialized()`once at startup (loads the WASM module on web, no-op elsewhere).

Akamai processes 3.2 trillion daily serverless edge requests in 2026 with sub-10ms cold starts and WebAssembly support, transforming its CDN into a global execution layer for real-time apps.

I wanted to know if WebAssembly runtimes are getting faster.

Most "Shopware vs Shopify" posts compare dashboards, app stores, and pricing tables. None of that matters to you until the day a client asks for something the platform won't let you build. Then the comparison stops being a feature grid and becomes a question about ceilings: **how high can I go before the platform says no, and what happens when I hit it?** That's the only axis I care about as a developer, so that's the one I'll argue on. Shopify is an outstanding product. It's also a closed SaaS that decides, on your behalf, where customization ends. Shopware is open source built on Symfony, which means the ceiling is "however far PHP and HTTP will take you." Below are the three places that difference actually bites, with code. ## Angle 1: The checkout is the wall This is the headline because it's where most agency developers first hit something they cannot do. For years the Shopify answer to "customize the checkout" was `checkout.liquid`. That era is over. Shopify deprecated `checkout.liquid` in favour of **Checkout Extensibility**. Plus stores had to migrate their Thank-you and Order-status pages by **August 28, 2025** , and in January 2026 Shopify began auto-upgrading stores — wiping customizations built on additional scripts, script-tag apps, or `checkout.liquid`. Non-Plus stores have until **August 26, 2026** , and legacy Shopify Scripts keep working only until **June 30, 2026**. (Shopify migration timeline) The replacement, Checkout Extensibility, is genuinely more upgrade-safe. It's also a smaller box. You get **Checkout UI Extensions** (declarative components that render in slots Shopify defines) and **Shopify Functions** for backend logic — and that's the surface. You don't own the checkout template; you decorate the pieces Shopify exposes. Worth noting: full visual checkout customization (branding API, custom fields beyond the defaults, full UI extension power) is gated to **Shopify Plus** anyway. On Shopware, the checkout is a Twig template like every other page, and you override it the same way you override anything else — by extending a block: {# MyPlugin/src/Resources/views/storefront/page/checkout/confirm/index.html.twig #} {% sb_extends '@Storefront/storefront/page/checkout/confirm/index.html.twig' %} {% block page_checkout_confirm_tos %} {# Inject a B2B purchase-order field right above the terms checkbox #} <div class="po-number-field"> <label for="poNumber">{{ "checkout.poNumberLabel"|trans }}</label> <input type="text" id="poNumber" name="poNumber" value="{{ page.extensions.poNumber ?? '' }}" /> </div> {{ parent() }} {% endblock %} No slot has to exist for this. No feature has to be on a pricing tier. You're editing the checkout's actual markup, in the same templating language as the rest of the storefront, and your override survives core updates because it extends rather than replaces. The Shopify equivalent — arbitrary markup in the middle of the checkout flow — is simply not a thing you can do, on any plan. ## Angle 2: Backend logic — a 5ms sandbox vs. the whole framework Say the requirement is a non-trivial discount: _"15% off, but only for B2B customers in a specific customer group, only on products from suppliers we flag as overstocked in an external ERP, and only Monday–Wednesday."_ On Shopify this is a **Shopify Function** : Rust or JavaScript compiled to WebAssembly. It's clever engineering, but read the constraints before you design against it. A function's Wasm module must be **≤ 256 KB** , may execute **≤ 11 million instructions** , runs under a **~5 ms** execution budget, is **fully sandboxed** (isolated memory, no network calls out to your ERP), and **forbids nondeterminism — no clock, no random**. Functions also can't be chained or made aware of each other. (Shopify Functions / WebAssembly docs) Look at that list against the requirement. "Only on overstocked products from an external ERP" needs a network call — not allowed in the function. "Monday–Wednesday" needs the clock — not allowed. So the real-world implementation becomes: a separate hosted app syncs ERP + day-of-week state into metafields out-of-band, and the function reads those metafields. You can ship it, but the platform pushed a chunk of your domain logic out of the function and into infrastructure you now operate and keep in sync. Here's the shape of what you're allowed to do inside the function — pure, deterministic, metafield-fed: // Shopify Function (JS → Wasm). No network, no Date.now(), ≤5ms, ≤256KB. export function run(input) { const discounts = input.cart.lines .filter((line) => line.merchandise.product?.isOverstocked?.value === "true") .map((line) => ({ targets: [{ cartLine: { id: line.id } }], value: { percentage: { value: "15.0" } }, })); return { discounts, discountApplicationStrategy: "FIRST" }; } On Shopware the same rule is an event subscriber in ordinary PHP, with the full container at your disposal — the database, HTTP clients, your ERP service, the clock, everything: <?php // MyPlugin/src/Subscriber/OverstockDiscountSubscriber.php namespace MyPlugin\Subscriber; use Shopware\Core\Checkout\Cart\Cart; use Shopware\Core\Checkout\Cart\Event\CartChangedEvent; use Symfony\Component\EventDispatcher\EventSubscriberInterface; class OverstockDiscountSubscriber implements EventSubscriberInterface { public function __construct( private readonly ErpClient $erp, // your own HTTP service private readonly DiscountFactory $factory // injected, like any Symfony service ) {} public static function getSubscribedEvents(): array { return [CartChangedEvent::class => 'applyOverstockDiscount']; } public function applyOverstockDiscount(CartChangedEvent $event): void { $cart = $event->getCart(); $weekday = (int) (new \DateTimeImmutable())->format('N'); // 1..3 = Mon..Wed if ($weekday > 3) { return; } // A real network call to your ERP — impossible inside a Shopify Function $overstockedSkus = $this->erp->fetchOverstockedSkus(); foreach ($cart->getLineItems() as $item) { if (in_array($item->getReferencedId(), $overstockedSkus, true)) { $this->factory->applyPercentage($cart, $item, 15.0); } } } } The point isn't that PHP is nicer than Rust. It's that **the entire business rule lives in one place, inside the request, with no sandbox to design around.** Shopify's model is safer and more scalable by construction — that's a real trade-off, not a slur — but it's a model where the platform decides which parts of your logic are allowed to run where. Shopware doesn't make that decision for you. ## Angle 3: Where your code lives This one is structural and easy to underrate. A Shopify app is an **external application**. It runs on infrastructure you host, talks to the store over OAuth and the Admin/Storefront APIs, and reacts via webhooks. Your code is never _in_ the store; it's a satellite orbiting it through a rate-limited API. That's a clean boundary, and for many integrations it's the right one. But it means even small backend tweaks become a deployed, authenticated, separately-monitored service — and you're always one API version or rate-limit window away from the platform. A Shopware plugin is a **Symfony bundle that lives inside the application**. The class hierarchy is literal: your plugin extends `Plugin`, which extends `Bundle`, which extends Symfony's `Bundle`. (Shopware: Plugins for Symfony Developers) So a plugin is just a Symfony bundle with conventions, and standard framework wiring applies: MyPlugin/ ├── composer.json └── src/ ├── MyPlugin.php # extends Shopware\Core\Framework\Plugin ├── Resources/ │ ├── config/ │ │ ├── services.xml # DI: register your subscribers/services │ │ └── routes.xml │ └── views/storefront/... # Twig overrides (see Angle 1) ├── Subscriber/ │ └── OverstockDiscountSubscriber.php # runs in-process (see Angle 2) └── Migration/ └── Migration1700000000Example.php # owns its own schema changes <?php // MyPlugin/src/MyPlugin.php namespace MyPlugin; use Shopware\Core\Framework\Plugin; class MyPlugin extends Plugin { // It's a Symfony bundle. Services in services.xml autoload, // routes register, migrations run on install. No external host, // no OAuth handshake, no API version to chase. } Your subscriber from Angle 2 and your Twig override from Angle 1 are the same deployable unit — one bundle, in the same process as the shop, sharing its container and database. There's no satellite to operate. ## The honest trade-offs I'd be doing the dishonest version of this post if I stopped there. Shopify's closed model buys you things that are genuinely hard to replicate: you never patch a server, the checkout converts extremely well out of the box, PCI scope is mostly Shopify's problem, and the sandboxed Functions model means one tenant's bad discount logic can't take down the platform. For a merchant who wants to sell, not to operate software, that's often the correct choice — and as a developer you should say so. There's also a cost angle that's easy to forget mid-architecture-debate: if you use any payment gateway other than Shopify Payments, Shopify adds a **third-party transaction fee** — 2% on Basic, scaling down to 1% (Grow), 0.6% (Advanced), and 0.2% (Plus). (Shopify third-party transaction fees) Self-hosted Shopware has no such cut — but you (or your host) now own uptime, security patching, and scaling, which is not free either. You're trading a platform fee for an operational burden. Which one is cheaper depends entirely on the project. Shopware's openness is power _and_ responsibility. The ceiling is high because there basically isn't one — and the flip side of "there's no sandbox to design around" is "there's no sandbox protecting you from yourself." ## So when does the open platform win? When the requirement is the thing the closed platform won't let you build. A checkout that needs custom markup, not a Shopify-defined slot. Business logic that has to call your ERP synchronously and consult the clock. A backend tweak that belongs in-process, not in a separately-hosted, OAuth'd, rate-limited satellite. The moment a project has two or three of those, the Shopify ceiling stops being theoretical and starts costing you weeks of working around it — and Shopware's "it's just Symfony" stops being a slogan and starts being the reason you ship on time. Pick Shopify when you want the platform to make decisions for you. Pick Shopware when you need to make them yourself. As a developer, you already know which kind of project lands on your desk. _I'm CTO atnextlevels, a German digital agency and Shopware Silver Partner. We build Shopware shops, custom software, and AI workflows for B2B Mittelstand clients — so I've shipped enough of both platforms to have opinions. Happy to argue the trade-offs in the comments._

Smart Flutter Web Framework v2.0 - SEO, SSR, pre-rendering, AI optimization for Flutter. The ultimate platform for building production-grade web apps with Flutter. Changelog excerpt: ### Major improvements - Complete rewrite of the core framework with production-ready architecture - Multi-platform support (web, iOS, Android, desktop) - Advanced SEO engine with dynamic meta tags, Open Graph, JSON-LD ### New features - Smart Router with dynamic route parameter matching (`/user/:id`) - Middleware and route guard execution system - Improved SSR renderer with lazy initialization - PWA Service Worker with cache versioning and stale-while-revalidate strategy - Image optimizer wi[...]