ykiko's blog

Building an Elegant C++ Cross-Platform Development and Build Workflow

Sat, 20 Dec 2025 22:51:31 +0000

C++ build issues have always been a hot topic, especially in various language wars, where they are often used as a negative example. Interestingly, most C++ programmers are often involved in maintaining existing systems, facing highly solidified, unchangeable build processes. The number of people who actually need to set up a project from scratch is in the minority.

Support AOT for CuTe DSL

Tue, 11 Nov 2025 13:38:08 +0000

Why do we need AOT for CuTe DSL?

CUTLASS C++ is a library for writing high-performance CUDA operators, known for its complexity and difficulty. To reduce the learning curve, NVIDIA introduced the Python-based CuTe DSL. Using Python instead of C++ templates for metaprogramming offers many benefits. First, users no longer have to struggle with the obscure template errors of C++, which is a major headache for C++ beginners; now they can focus on the code logic. Additionally, nvcc compilation is slow, and most of that time is spent in the compiler frontend, parsing C++ code. Especially for template-heavy libraries like CUTLASS, most of the time is spent processing template instantiations. Using CuTe DSL can bypass this issue. Compared to C++ code using CUTLASS, its compilation speed can be tens or even hundreds of times faster. Furthermore, operators and unit tests can now be written together in Python, which is much more convenient.

Clice, how have you been lately?

Thu, 24 Jul 2025 15:26:56 +0000

Last night, I bought the domain name clice.io and deployed clice’s documentation website on it. There’s an indescribable joy in my heart. On one hand, I really like the clice.io domain; it looks very refined and beautiful. I actually had a few other candidates, such as .dev, but in the end, I chose this one, which is relatively more expensive (500 per year) but looks better. On the other hand, it signifies that clice has entered a new phase.

Reflection for C++26!!!

Sat, 21 Jun 2025 17:33:11 +0000

At the C++26 Sofia meeting, which just concluded yesterday, seven proposals related to Static Reflection:

Deep Dive into Clang (Part 1)

Tue, 04 Feb 2025 21:00:55 +0000

After the article about clice was published, the response I received far exceeded my expectations, and many friends expressed a desire to participate in the development. While this enthusiasm is good, the barrier to entry is not low, mainly due to the difficulty of interacting with clang’s API. What makes it difficult? On the one hand, there is relatively little information about clang on the internet, whether in Chinese or English communities (this is expected, as there is very little demand for it, so naturally few people discuss it). On the other hand, due to the complexity of the C++ language itself, many details require a deeper understanding of the language before they can be grasped, and connecting theory with implementation is not easy.

Design and Implementation of a New C++ Language Server

Wed, 18 Dec 2024 13:46:01 +0000

It’s been several months since my last blog post. The reason for this long hiatus is that I’ve been busy working on clice – a brand new C++ language server.

St. Louis WG21 Meeting Review

Mon, 01 Jul 2024 18:46:56 +0000

Due to a series of coincidences, I participated in last week’s WG21 meeting (the C++ Standards Committee meeting). Although I often browse new proposals for the C++ standard, I never expected to one day actually attend a WG21 meeting and get real-time updates on the latest progress of the C++ standard. Of course, this was my first time attending, and I was very excited. I’m writing this to record my feelings and the progress of the meeting.

The Perfect Combination of Python and C++: Object Design in pybind11

Fri, 07 Jun 2024 07:28:11 +0000

I participated in Google Summer of Code 2024. The main task was to implement a pybind11-compatible interface for a Python interpreter. Saying “implement a compatible interface” is somewhat of an understatement — it was essentially a rewrite of pybind11, so I’ve been spending a lot of time reading through its source code lately.

Is the singleton pattern in C++ truly a 'singleton'?

Thu, 09 May 2024 18:08:28 +0000

Singleton Pattern is a common design pattern, often applied in scenarios such as configuration systems, logging systems, and database connection pools, where object uniqueness must be ensured. But can the Singleton Pattern truly guarantee a single instance? What are the consequences if uniqueness is not guaranteed?

Super easy-to-use C++ Online Compiler (VSCode Version)

Wed, 24 Apr 2024 13:35:41 +0000

Compiler Explorer is a very popular online C++ compiler, which can be used to test different compilation and execution environments, or to share code. As a C++ enthusiast, I interact with it almost every day, and its frequency of use far exceeds my imagination. At the same time, I am also a heavy VSCode user, completing almost everything within VSCode. Considering that I often write code locally and then copy it to Compiler Explorer, it always felt uncomfortable. Sometimes I would directly modify it on its web editor, but without code completion, that was also uncomfortable. Therefore, I collaborated with @iiirhe to write this extension Compiler Explorer for VSCode, which integrates Compiler Explorer into VSCode based on the API provided by Compiler Explorer, allowing users to directly use Compiler Explorer’s features within VSCode.

Thoroughly Understanding C++ ABI

Tue, 16 Apr 2024 18:19:38 +0000

Application Binary Interface, or ABI as we commonly call it, is a concept that feels both familiar and unfamiliar. Familiar in what sense? It’s often discussed when troubleshooting, frequently mentioned in articles, and sometimes we even have to deal with compatibility issues it causes. Unfamiliar in what sense? If someone asks you what an ABI is, you’ll find that you know what it’s about, but describing it in precise language is quite difficult. In the end, you might just resort to saying, as WIKI does: an ABI is an interface between two binary program modules. Is there a problem with that? No, as a general description, it’s sufficient. But it can feel a bit hollow.

Where exactly does C++ code bloat occur?

Mon, 11 Mar 2024 01:33:37 +0000

Readers probably often hear people say that C++ code suffers from severe binary bloat, but usually few people point out the specific reasons. After a search online, I found that there aren’t many articles that delve deeply into this issue. The above statement is more like part of a cliché, passed down by word of mouth, but few can explain why. Today, your editor ykiko will take everyone on a journey to explore the ins and outs of C++ code bloat (^ω^)

The History of constexpr in C++! (Part Two)

Thu, 22 Feb 2024 14:15:32 +0000

Prequel: The History of constexpr in C++! (Part One)

2015-2016: Syntactic Sugar for Templates

In C++, there are many templates that support full specialization, but not many that support partial specialization. In fact, only class templates and variable templates support it. Variable templates can actually be seen as syntactic sugar for class templates, so rounding it up, only class templates truly support partial specialization. The lack of partial specialization can make some code very difficult to write.

The History of constexpr in C++! (Part One)

Sat, 10 Feb 2024 15:15:47 +0000

A few months ago, I wrote an article introducing C++ templates: Looking at Flowers in a Fog: A True Understanding of C++ Templates.

How to elegantly convert enum to string in C++?

Mon, 29 Jan 2024 09:03:28 +0000

no hard code

Define an enum

enum Color {
    RED,
    GREEN,
    BLUE
};

Try to print

Relocate Semantics in C++

Thu, 25 Jan 2024 09:22:29 +0000

As is well known, there are currently two special constructors in C++: the copy constructor and the move constructor.

A 7-Year Relay Race: Getting the Number of Fields in a C++ Struct

Mon, 25 Dec 2023 20:45:30 +0000

Introduction

In C++17, a feature called “structured binding” was introduced. This feature is similar to pattern matching in other languages and allows us to conveniently access members of a struct.

Implement Object in C++!

Sun, 03 Dec 2023 15:40:52 +0000

Static and Dynamic

The terms static typing and dynamic typing are probably familiar to everyone. The key to distinguishing between them lies in the timing of type checking. What does that mean?

Why is it said that C/C++ compilers do not preserve metadata?

Sun, 03 Dec 2023 15:37:51 +0000

First, what is metadata?

Consider the following python code. We want to automatically modify the corresponding field value based on the input string.

Master your C++ code with Clang tools.

Wed, 29 Nov 2023 01:14:27 +0000

Clang is a C-language family compiler frontend provided by the LLVM project. It was originally developed to replace the C language frontend of the GNU Compiler Collection (GCC), with the goal of providing faster compilation speeds, better diagnostic information, and a more flexible architecture. Clang includes C, C++, and Objective-C compiler frontends, which are designed to be embedded in other projects. A key feature of Clang is its modular architecture, which makes it easier for developers to extend and customize compiler functionality. Clang is widely used in many projects, including LLVM itself, the development of some operating system kernels, and the implementation of compilers for some programming languages.

Various approaches to code generation

Wed, 29 Nov 2023 01:14:16 +0000

Introduction

Let’s take a recent requirement as an introduction. We all know that Markdown can use lang to fill in code blocks and supports code highlighting. However, I wanted to support my own custom code highlighting rules and encountered the following problems:

A Reflection Tutorial for C++ Programmers

Wed, 29 Nov 2023 01:14:02 +0000

What is Reflection?

The term Reflection is probably not new to anyone; perhaps you haven’t used it, but you’ve certainly heard of it. However, like many other idiomatic terms in the CS field, there isn’t a clear and precise definition for reflection. This leads to a situation where, for languages like C#, Java, and Python that have reflection, discussing it naturally brings to mind related facilities, APIs, and code examples in those languages, making it very concrete. But for languages like C, C++, and Rust, which don’t have reflection, when reflection is discussed, people are often unsure what the other person is referring to, making it very abstract. For example, someone might tell me that Rust has reflection, and the example they provide is the introduction to std::Any module in Rust’s official documentation. It mentions:

C++26 Static Reflection Proposal Analysis

Mon, 16 Oct 2023 18:38:26 +0000

Recently, I’ve been planning to write a series of articles discussing the concept of reflection in detail. Coincidentally, C++26 has a new reflection proposal, and I noticed there aren’t many related articles on Zhihu, despite this topic being frequently discussed. So, I’m taking this opportunity to talk about static reflection in C++, as a warm-up for the series.

C++ Pointers to Members: A Comprehensive Guide

Wed, 04 Oct 2023 06:50:12 +0000

Introduction

In C++, an expression like &T::name returns a pointer to member. It’s occasionally used when writing code, but this concept might not be familiar to many. Consider the following code:

Seeing Through the Fog: A True Understanding of C++ Templates

Tue, 12 Sep 2023 15:46:11 +0000

The concept of templates in C++ has existed for over twenty years. As one of the language’s most important constructs, there is no shortage of related discussion. Unfortunately, truly in-depth and valuable discussions are rare — especially those that examine the feature from multiple perspectives. Many articles on templates tend to entangle the topic with various syntactic details, easily leaving readers with a hazy impression. Similar things happen elsewhere: introductions to coroutines often mix them with all kinds of I/O concerns, and discussions of reflection seem confined to reflection in Java or C#. This isn’t unreasonable, but it often leaves readers unable to grasp the essence. After consuming a lot of content, one still can’t get to the heart of the matter, and it becomes easy to conflate different concepts.

C++ Forbidden Black Magic: STMP (Part 2)

Sun, 30 Jul 2023 01:29:27 +0000

In the previous article, we gained a preliminary understanding of the principles of STMP and used it to implement a simple compile-time counter. However, its power extends far beyond that. This article will discuss some advanced applications based on STMP.

C++ Forbidden Black Magic: STMP (Part 1)

Sat, 29 Jul 2023 10:20:50 +0000

As is well known, traditional C++ constant expression evaluation neither depends on nor changes the global state of the program. For any identical input, its output is always the same, and it is considered purely functional. Template Meta Programming, as a subset of constant evaluation, should also adhere to this rule.

std::variant is hard to use!

Tue, 25 Jul 2023 07:19:25 +0000

std::variant was added to the standard library in C++17. This article will discuss the background of its inclusion and some issues related to its usage.