Why I Built a Sales Tracker for WhatsApp Sellers🎥Kea Sigma DeltaWelcome to SwedenCpp
Latest blogs, videos, podcasts and releases in one stream
Monday, May 11, 2026
Why I Built a Sales Tracker for WhatsApp Sellers🎥Kea Sigma Delta
Why I Built a Sales Tracker for WhatsApp Sellers🎥Kea Sigma DeltaIf this page is useful, please consider your support
Sunday, May 10, 2026
Lightning Talk: std::move & Spirited Away: When Nameless Objects Walk the Spirited World🎥CppConSaturday, May 9, 2026
Lecture 25. Coroutines, part I: Co-operators and Promises (MIPT, 2025-2026).🎥Konstantin Vladimirov
Lightning Talk: Promote Modern C++ Usage With Coding Questions Part 2 - Zhenchao Lin - CppCon 2025🎥CppConFriday, May 8, 2026
An Immigrant's Love Letter to the West by Konstantin KisinI recently stumbled upon the TRIGGERnometry podcast, which brands itself as a “free speech show”. It’s hosted by two (former) comedians, Konstantin Kisin and Francis Foster. I usually listen to these podcasts while working out, and what I really appreciate about them is that they host people with very different views and always have respectful, unfiltered discussions. Yes, honest debate without...📝Sandor Dargo's Blog
C++ for High Performance Web Application Backends - Uzochukwu Ochogu - C++Online 2026🎥CppOnline
Developing more confidence when tracking renames via ReadDirectoryChangesWYou can track the file ID. The post Developing more confidence when tracking renames via ReadDirectoryChangesW appeared first on The Old New Thing .📝The Old New Thing
Converting Source Separation Models to ONNX for Real Time Usage in DJ Software - Anmol Mishra - ADC🎥audiodevcon
Qt Creator 20 Beta releasedWe are happy to announce the release of Qt Creator 20 Beta!📝Qt Blog
Two-Minute _Iolanthe_The other day I came across Connie Kleinjans’ page of “two-minute versions” of G&S shows. She’s got two versions of Gondoliers and one each of Iolanthe and Ruddigore. The technique is the same as in blackout poetry: take the whole work and black out all but the most important and/or funniest bits.📝Arthur O’DwyerThursday, May 7, 2026
Partner with Kitware to Accelerate Medical Software Product DevelopmentDeveloping medical software is complex. From early-stage concepts to production-ready systems, organizations must navigate technical challenges, clinical requirements, and regulatory considerations, all while moving quickly and managing risk. Kitware partners with medical device companies, digital health innovators, and research organizations to accelerate the development of advanced medical software products. By combining deep domain expertise with open source platforms and advanced visualization technologies, we help teams move efficiently from concept to deployable solutions.📝Kitware Inc
Project-Specific Build Optimizations with GitHub CopilotWe are excited to announce that GitHub Copilot build performance for Windows now supports project-specific builds! Available in the latest Visual Studio Insiders, you can target a single MSBuild project or CMake target instead of analyzing your entire solution. For game developers and teams working with large codebases, this eliminates the need to wait for […] The post Project-Specific Build Optimizations with GitHub Copilot appeared first on C++ Team Blog .📝C++ Team Blog
What’s New in vcpkg (Apr 2026)These updates include improved locking for parallel builds, cross-platform PE dependency analysis, manifest support for the depend-info command, and other improvements and bug fixes. The post What’s New in vcpkg (Apr 2026) appeared first on C++ Team Blog .📝C++ Team BlogWhen you upgrade your resource strings to Unicode, don’t forget to specify the L prefixOtherwise, it'll get mapped back down to the 8-bit code page. The post When you upgrade your resource strings to Unicode, don’t forget to specify the L prefix appeared first on The Old New Thing .📝The Old New Thing
Singleton Controllers in Times of Declarative QMLTo make it easier to provide controller objects to QML, André Somers contributed some changes to QQmlEngine and the declarative registration code, so that you can now provide object instances to the QML engine to use as singletons.📝KDABWednesday, May 6, 2026
Checking multiplication overflowSuppose that x is a variable of an unsigned type. In C/C++, it could be of type size_t for example. You have an expression like 6 * x and you want to know whether 6 * x overflows. That is, you want to know if 6 * x exceeds the range of values that can … Continue reading Checking multiplication overflow📝Daniel Lemire's blogWhy not have changes in API behavior depend on the SDK you link against?Static libraries don't stand a chance. The post Why not have changes in API behavior depend on the SDK you link against? appeared first on The Old New Thing .📝The Old New Thing
Lightning Talk: Learning C++ Through Writing Coding Questions - Christopher DeGuzman - CppCon 2025🎥CppConSecurity advisory: Type confusion and heap-buffer-overflow vulnerability in Qt SVG marker handling impacts QtType Confusion and Heap-based Buffer Overflow vulnerability in the SVG marker and mask handling of the Qt SVG module has been discovered and has been assigned the CVE id CVE-2026-6210 .📝Qt Blog
Top C++ Skills from Candidates and the Meeting C++ Survey🎥MeetingCpp
Using Kotlin/Compose Multiplatform to Revive a Historic Multiplayer Online Drum Machine - Phil Burk🎥audiodevcon
Qt Design Studio 4.8.2 ReleasedQt Design Studio 4.8.2 Is Here! Following our 4.8.1 release , which introduced the Qt Design Studio AI Assistant in beta, we are back with a significant evolution of that feature, along with a few other updates. The 4.8.1 release laid the groundwork, a prompt-based tool that could generate QML from a natural language description or an image. That was a strong foundation, and the feedback we received helped shape where we took it next. In 4.8.2, the assistant has been rebuilt around a fundamentally more powerful architecture, and the difference in what you can accomplish with it is substantial. Qt Design Studio Goes Agentic With 4.8.2, Qt Design Studio takes a major step forward by introducing a fully agentic AI Assistant powered by the Model Context Protocol (MCP), an open standard for connecting AI models to external tools and data sources. This shift transforms the assistant from a passive helper into an active collaborator. Instead of working on a single file, it now understands your entire project structure and can operate across it using a rich set of MCP tools: reading files, creating components, modifying existing ones, and more. When you describe a goal, the assistant enters an agentic loop. It plans the task, selects the appropriate tools, executes them, evaluates the results, and continues iterating until the objective is complete. Every step is logged in the chat, so you can follow the process. Built on MCP, the assistant is designed to be extensible and future-proof, enabling integrations with external MCP server. The assistant supports leading models from Anthropic, Google, and OpenAI, and you can switch between providers within the same conversation. The agentic AI assistant is available to all Qt Design Studio users, we encourage you to try it out and share your feedback. Agentic AI at Work: Medical UI demo Created from a Single Prompt Qt Kit Updated to 6.8.7 This release also bumps the bundled Qt Kit from 6.8.5 to 6.8.7, picking up the latest stability and maintenance improvements from the Qt 6.8 series. Further Information Our change log contains the full list of fixes and improvements included in this release. If you run into any bugs or usability issues, please report them in the issue tracker — your feedback helps us improve every release. New to Qt Design Studio? Explore the online documentation or head to the learning portal to get up to speed. We look forward to hearing what you build with the new agentic assistant!📝Qt Blog
Enabling cybersecurity research using D - Brian Callahan - D Language Symposium 2026 - Talk 7 of 8🎥Mike Shah
Improving Python Dependency Handling for 3D Slicer Extension Development3D Slicer is a multi-platform medical image informatics and visualization application, and a sizable fraction of its functionality lives in extensions. Many of those extensions are written in Python, and many of them depend on third-party Python packages: PyTorch for deep learning models, scikit-image for filtering, nnUNet for segmentation, and so on. How those dependencies […]📝Kitware IncC++ Alignment Chart📝Arthur O’DwyerTuesday, May 5, 2026
Sovereignty by DisruptionA full length novel📝My Very Best AI Slop
Mapping Strings to Float Arrays in Go: How Fast Can We Go?A common pattern in modern software is to map a string key to a small array of floating-point numbers. Word embeddings, feature vectors, lookup tables for physical constants: all variations on the same theme. In Go, the obvious way to write this is a map[string][]float32. But how fast is it, really, and can we do … Continue reading Mapping Strings to Float Arrays in Go: How Fast Can We Go?📝Daniel Lemire's blog
Announcing Girder 5A Modern and Scalable Data Management Platform We are delighted to announce the release of Girder 5, a major rewrite that brings modern development practices, improved scalability, and a more maintainable codebase to our popular data management platform. Girder has been the core infrastructure behind HistomicsTK and the Digital Slide Archive and is used with […]📝Kitware IncA dispute over the TAB key highlights a mismatch between Microsoft and IBM organizational structuresI want to speak to your manager. The post A dispute over the TAB key highlights a mismatch between Microsoft and IBM organizational structures appeared first on The Old New Thing .📝The Old New Thing
Lightning Talk: Back When ChatGpt Was Young And Stupid - Andrei Zissu - CppCon 2025🎥CppCon
Construct with Collaborators, Call with Work@media only screen and (max-width: 600px) { .body { overflow-x: auto; } .post-content table, .post-content td { width: auto !important; white-space: nowrap; } } This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office. By Shahar Roth Classes require various objects and parameters to function. The "Construct with Collaborators, Call with Work" guideline can help you construct effective inputs: Use the constructor for collaborators—the dependencies that establish the object’s identity. Collaborators stay with the object for its lifetime to enable it to fulfill its ongoing duties. Pass work—the parameters that change with each interaction—to methods. Unique to each call, these inputs provide the specific data needed for an operation such as a file path or database query. Consider a ReportGenerator that needs a database, a formatter, and a date range to generate a report. The database and formatter , as collaborators, are injected via the constructor, while dateRange , which varies per report generation, is passed as a method parameter to the generate method: class ReportGenerator { private final Database database ; private final Formatter formatter ; // database and formatter are passed as collaborators. ReportGenerator(Database database , Formatter formatter ) { this. database = database ; this. formatter = formatter ; } // dateRange is passed as a parameter. Report generate(Range dateRange ) { return formatter .format( database .getRecords( dateRange )); } } A single ReportGenerator object can generate multiple reports with different date ranges: ReportGenerator generator = new ReportGenerator( database , formatter ); Report report1 = generator.generate( dateRange1 ); Report report2 = generator.generate( dateRange2 ); Following the "Construct with Collaborators, Call with Work" guideline promotes : Reusability: Enables instances to be used for multiple, distinct operations. Testability: Separates dependency setup from business logic. Cleaner code: Hides implementation dependencies from the object’s users. Predictable behavior: Locks in dependencies at creation time. Note that the definition of "collaborator" versus "work" depends on the object's identity. For example, a RequestMessage could be a collaborator for a RequestHandler if the handler operates on a single request, or work if the handler processes different requests with each method call.📝Google Testing Blog
Introducing the QML Profiler Skill for Agentic DevelopmentInstead of a painstaking row-by-row or slow flame graph reviews, the QML profiler skill for agentic development allows developers to delegate code performance profiling to AI agents. The skill guides the developer through the workflow, triggers the QML profiler, crunches through the resulting raw data, presents the performance bottlenecks in a concise report, and suggests improvements. The skill targets 2D Qt Quick applications and supports four profiling modes — rendering, logic, memory, and full. It can also analyze an existing trace file directly, without re-running the application, for example, if the performance trace has been run on the target hardware. Video: QML profiling of shopping list app in Claude Code CLI (Some sequences are shortened or accelerated)📝Qt BlogELF’s ways to combine potentially non-unique objectsPreviously [I wrote](/blog/2026/04/24/define-static-array/): > [Template parameter objects of array type] are permitted to overlap or be > coalesced, just like `initializer_list`s and string literals. Clang trunk > isn't smart enough to coalesce potentially non-unique objects [but] > GCC, once it implements `define_static_array`, will presumably make them the same. Well, GCC 16 has an experimental implementation of `define_static_array` (compile with `g++ -std=c++26 -freflection`), and it does _not_ coalesce template parameter objects of array type in the way I expected. Digging deeper into why not, I learned that there are at least three ways compilers and linkers (on ELF — that is, non-Windows — platforms) conspire to "merge" potentially non-unique objects: * Merging at the compiler level (for `initializer_list` backing arrays) * Sections with `SHF_MERGE` (for string literals and backing arrays) * Sections with `SHF_GROUP`, a.k.a. COMDAT sections (for inline variables)📝Arthur O’Dwyer
From Undefined to Defined: Using std::launder in C++In today's post, I will continue with the overall topics of the last two months. Today you'll learn when and where you need to apply C++17's std::launder and where the difference to this utility is to reinterpret_cast or std::start_lifetime_as . The fields where you can apply today's learning …📝AndreasFertig.com
Introducing conan-py-build: Build Python Wheels with ConanPackaging Python extensions that contain native C or C++ code has come a long way. PEP 517 defined a contract between Python build frontends ( pip , build , uv ) and the build backend that produces the wheel. That standard is what makes it possible today to connect a CMakeLists.txt to a pyproject.toml , declare a backend, and let pip wheel . drive the build. The C/C++ dependency layer is a different story. Somewhere between pyproject.toml and CMakeLists.txt , a find_package(OpenSSL) has to resolve. In practice, most projects solve that outside the wheel build: through system packages, vendored source trees, FetchContent or a separate native package manager install step. That means a separate step to manage before the Python build, often duplicated across CI configurations and developer setups. Today, we are happy to introduce conan-py-build , a PEP 517 build backend that brings Conan’s C/C++ dependency management directly into the Python wheel build. The project is currently in beta and under active development. We are releasing it now to gather early feedback, and we would love for you to try it and tell us what you think. What is conan-py-build? conan-py-build is a build backend for Python packages that contain native C/C++ extensions. You declare it in pyproject.toml , provide a conanfile.py that describes the C/C++ build and its dependencies, and build wheels through standard Python packaging commands such as pip wheel . . When a build runs, conan-py-build : Resolves the C/C++ dependency graph through Conan, downloading precompiled binaries where available and building the rest from source Prepares the build toolchain through the corresponding Conan generators Builds the extension using your project’s build system When the extension links against shared libraries, copies those runtime dependencies next to the extension module and patches RPATH on Linux and macOS where applicable Packages the result into a standard Python wheel Because it is a PEP 517 backend, it plugs into pip , build , and uv directly, and fits into cibuildwheel -based CI workflows for multi-platform builds. A minimal example Let’s build a tiny Python package that exposes a single function, greet(name) , which prints a colored greeting to the terminal. We’ll use CMake for the native build, pybind11 for the Python bindings, and {fmt} as a dependency pulled in through Conan. The same setup extends to other build systems like Meson or Autotools. The project layout: mypackage/ ├── pyproject.toml ├── conanfile.py ├── CMakeLists.txt └── src/ ├── mypackage/ │ └── __init__.py └── mypackage.cpp pyproject.toml declares the build backend and the project metadata: [build-system] requires = ["conan-py-build"] build-backend = "conan_py_build.build" [project] name = "mypackage" version = "0.1.0" conanfile.py describes the C/C++ side: its dependencies ( pybind11 and fmt ) and how they are built and packaged. from conan import ConanFile from conan.tools.cmake import CMake , cmake_layout class MyPackageConan ( ConanFile ): settings = "os" , "compiler" , "build_type" , "arch" generators = "CMakeToolchain" , "CMakeDeps" def layout ( self ): cmake_layout ( self ) def requirements ( self ): self . requires ( "pybind11/3.0.1" ) self . requires ( "fmt/12.1.0" ) def build ( self ): cmake = CMake ( self ) cmake . configure () cmake . build () def package ( self ): cmake = CMake ( self ) cmake . install () CMakeLists.txt builds the extension against pybind11 and fmt and installs the resulting module into the Python package directory so the backend picks it up when assembling the wheel: cmake_minimum_required ( VERSION 3.15 ) project ( mypackage LANGUAGES CXX ) set ( PYBIND11_FINDPYTHON ON ) find_package ( pybind11 CONFIG REQUIRED ) find_package ( fmt CONFIG REQUIRED ) pybind11_add_module ( _core src/mypackage.cpp ) target_link_libraries ( _core PRIVATE fmt::fmt ) install ( TARGETS _core DESTINATION mypackage ) The C++ source defines greet(name) using fmt’s color support and exposes it as a compiled _core module: #include #include #include void greet ( const std :: string & name ) { fmt :: print ( fmt :: fg ( fmt :: color :: green ), "Hello, {}! \n " , name ); } PYBIND11_MODULE ( _core , m ) { m . def ( "greet" , & greet ); } And src/mypackage/__init__.py re-exports it so callers see mypackage.greet : from mypackage._core import greet __all__ = [ "greet" ] With that in place, building the wheel is the standard Python packaging command: $ pip wheel . -w dist/ Conan resolves pybind11 and fmt from Conan Center Index, CMake compiles the extension against them, and you get a platform-specific wheel in dist/ . Install it and try it: $ pip install dist/mypackage- * .whl $ python -c "import mypackage; mypackage.greet('world')" Hello, world! You should see Hello, world! printed in green. More examples: the repo has nanobind bindings, shared library dependencies, C++ sources fetched at build time, and a full multi-platform cibuildwheel setup for Linux, macOS, and Windows. What conan-py-build brings Some of the advantages of bringing Conan into the wheel build: One build entry point. The usual pip wheel . command can drive both the Python packaging step and the native C/C++ dependency/build step. Conan Center. A large catalog of C/C++ libraries with recipes tested across a broad compiler and OS matrix. Binary caching. Compiled dependencies are reused across builds and CI runs via the Conan cache or a shared remote, rebuilt only when settings change. Profiles and lockfiles. Profiles define the native build configuration of each wheel (compiler, architecture, C++ standard, dependency options), and lockfiles pin the graph for reproducible builds. Shared library handling. Conan-managed runtime libraries are deployed next to the extension module, and RPATH is adjusted on Linux and macOS where applicable. Conclusions conan-py-build pulls the C/C++ dependency layer inside the PEP 517 build so the Python build and the C/C++ build are one problem, not two. If you have been maintaining a separate dependency step alongside your Python packaging, it is worth a look. Check out the documentation and browse the examples . conan-py-build is still in beta and available on PyPI . If something does not work, or there is a workflow you want supported, please open an issue on GitHub and let us know where it fits, or where it does not yet. Looking forward to your feedback.📝Conan C/C++ Package Manager Blog
What makes a game tick? Special Issue - Buffy the Performance SlayerLet's talk about game simulations. In this special issue we talk about how to handle buffs, modifiers and other stat bonuses.📝Mathieu Ropert