报告集合 · TECHSTACK

本机软件技术栈分析

一台真实开发机上,37 个桌面应用分别用什么技术栈构建,代价是多少,为什么这样选。 结论不从文档里抄,全部由磁盘上的二进制反推得出。

样本 37 个应用 合计 30.73 GB 实测数据 2026-10

00方法与可信度

这份报告不是从官方文档、发布会或技术博客里整理的。它的每一个分类结论,都来自对磁盘上二进制文件的直接检查——看一个应用目录里有哪些 DLL、主程序的导入表里挂了谁、可执行文件里残留着什么字符串。

之所以先说方法,是因为这套方法有明确的能力边界。它的证据强度是分级的,而分级的理由很具体:有些特征可以唯一确定一个技术栈,有些只能提供线索,还有一类会直接骗人。

三个识别层次

① 指纹文件 实测

应用目录里存在某个特定文件,就唯一确定技术栈。这是最强证据。

例:有 libcef.dll 就是 CEF;有 app.asar 就是 Electron;有 flutter_windows.dll 就是 Flutter。

② PE 导入表 文档

解析主程序的 PE 结构,看它到底链接了谁。适合判断"谁是主程序、谁是附属组件"。

例:UU远程的主程序导入了 Qt5Core.dll + WebView2Loader.dll + 自研的 streamer.dll——三层结构一目了然。

③ 字符串扫描 推断

目录里没有任何指纹文件时,只能读 exe 内容找特征串。证据最弱,最容易出错。

例:Tauri 应用的目录里什么标记都没有——它用的是系统 WebView2,内核不在自己目录里。只能从 exe 里搜 tauri://localhost 之类的串来认。

三个真实误判

下面这三条是本次分析实际踩到的坑,全部写出来,因为它们比结论本身更有用。

误判一:ghc 是 x86 机器码的巧合

用 ghc(GHC 是 Haskell 编译器的缩写)作为 Haskell 的识别标记,结果六个应用被误判为 Haskell——包括几个远程控制工具和一个终端软件。

抽查看上下文才发现:ghc 这三个字母是 x86 汇编指令码 Hc 加上随机字节的自然组合,在任何稍大的二进制里都会出现。

修正:Haskell 只认 libraries\base\GHC\List.hs、GHCRTS 这类长特征串。修正后全盘只剩一个真 Haskell 程序。

误判二:wry 三字母扫描污染了半个桌面

Tauri 的 WebView 绑定库叫 wry,我用它做标记,结果截图工具、聊天软件、版本控制工具全部被误判为 Tauri。

三到四字母的短串在二进制里命中率高得离谱。同一类错误在这次分析里出现了两次。

修正:只用 tauri://localhost、tauri.localhost、tauri-plugin 这类长度足够的串,且只扫主程序,不扫附属组件。

误判三:附属组件冒充主程序

修正短串问题后,仍有两个应用被误判为 Tauri。深挖发现:标记来自目录里的第三方附属可执行文件,不是主程序。其中一个甚至不是软件自带的组件,而是用户另外放入的工具。

修正:Tauri 判定只看快捷方式实际指向的主程序,不看目录里的其他 exe。修正后 Tauri 应用从 9 个降到 6 个。

一个概念陷阱

"不打包 Chromium" ≠ "不依赖 Chromium"

分析过程中曾把 Tauri 应用(DBX、PiDeck、CC GUI 等)归为"不依赖 Chromium",理由是它们的目录里找不到任何 Chromium 标记文件。

这个归类是错的。它们在 Windows 上依赖系统内置的 WebView2,而 WebView2 的实现就是 Chromium(Edge 的内核,Blink 排版引擎 + V8 脚本引擎)。内核只是不在应用目录里而已。

正确的区分轴不是"有没有 Chromium",而是 "Chromium 从哪来"——自带、共享系统、还是不涉及。三个不同的东西:打包 ≠ 依赖 ≠ 控制版本。

证据分级约定

级别含义本报告中的例子
实测本机扫描直接得出,可复现体积、文件清单、进程内存、安装时间
文档来自官方声明或项目 README向日葵放弃自研 UI 框架转 Flutter 的官方说明
推断由特征推测,未经官方确认ToDesk"主体是 C++/Qt"——从导入表推断
未查明有异常但没找到原因IntelliJ IDEA 进程占用 5.5 GB 内存的原因

凡是标 推断 的,都说明了推断依据;凡是没搞清的,直接标 未查明,不用猜测填空。


样本口径:以桌面与开始菜单的快捷方式为入口,共 41 条,去掉重复指向和已失效项后,得到 37 个实际安装且可启动的桌面应用。体积统计的是应用目录的完整占用(含缓存、运行时、历史版本)。

另外扫描了全盘 93 个应用目录用于交叉验证,但那 93 个里包含大量命令行工具、系统组件和卸载残留——37 个桌面应用才是"真正在用的软件",报告主口径用它。

01全景

先给结论:这批软件在磁盘上占 30.73 GB,其中 30.40 GB 来自 Chromium 相关的技术栈,只有 344 MB 来自完全不碰 Chromium 的原生应用。

比例是 90.5 倍。

37
桌面应用
30.73 GB
总体积
30.40 GB
Chromium 相关
344 MB
完全无关
90.5×
体积比

同一个问题,三个口径三个答案

这是整份报告最重要的一张表。同样一批软件,"Chromium 占多少"这个问题会因为你数什么而得出完全不同的结论。

口径Chromium 相关规模结论
按应用数3337占 89%——但分母里大小应用权重相同
按体积30.40 GB30.73 GB占 98.9%——压倒性
按运行内存8.10 GB31.63 GB占 26%(见第 4 节)

三个口径的差异本身就有信息量:Chromium 相关应用在磁盘上占 99%,在内存上只占 26%。原因是很多大体积应用(IDE、网盘、浏览器)大部分时间不在前台,内存占用远低于体积占用。而那些 3 MB、57 MB 的原生小工具,体积可以忽略,却可能一直开着。

体积分布

自带完整 Chromium
26,969 MB
共享系统 WebView2
2,535 MB
其他内核(Cronet 等)
875 MB
Tauri(Rust 外壳)
747 MB
Qt / C++ 原生
344 MB

21 个自带 Chromium 的应用吃掉 26.9 GB,剩下 16 个应用加起来 4.5 GB。

四个极端样本

应用类型体积内核相对倍数
夸克4,716 MBChromium + Electron + Flutter 三引擎基准
IntelliJ IDEA4,005 MBCEF + JBR0.85×
GitHub CLI(gh)40 MBGo 静态编译0.0085×
Everything3 MB纯 Win320.0006×

体积最大的应用和最小的应用相差 1,572 倍,而它们都在同一个桌面上、都是"打开就能用的软件"。

五个技术栈族的体积汇总

技术栈族体积内核归属
Electron13,965 MB自带完整 Chromium
CEF6,654 MB自带完整 Chromium
Chromium 裸内核5,946 MB自带完整 Chromium
WebView2 宿主2,535 MB共享系统内核
其他原生1,279 MB部分含 Cronet
Tauri747 MB共享系统内核
Qt344 MB无浏览器内核

值得单独指出的是:六个 Tauri 应用合计 747 MB,平均每个 124 MB;而二十一个自带 Chromium 的应用平均每个 1,284 MB。平均体积差了十倍以上。

02分层结构

把 37 个应用按"从上到下"拆开看,会出现一个非常清晰的规律:越往上越自由,越往下越被 C/C++ 锁死。

这不是因为 C++ 有多好,而是因为三层结构性约束:图形接口、操作系统接口、以及跨语言调用的 ABI 契约,全部都是 C 或 C++ 定义的。任何语言想碰到底层,最终都必须走这条通道。

四层模型

层语言本机证据
第 4 层
应用代码
百花齐放TypeScript / Dart / Java / Rust / Go / C# / C++
第 3 层
运行时
C++ 为主V8(JS 引擎)、JVM、CoreCLR、Dart 运行时——全是 C++
第 2 层
引擎
C / C++ 垄断Blink(排版)、Skia(绘制)、V8、FFmpeg、Qt
第 1 层
操作系统
CWindows 内核、Win32 API

四层里只有第 4 层是由开发者自由选择的。第 2 层和第 3 层你想换也换不掉——除非你像 Rust 那样,把整个运行时栈自己重写一遍。

证据:C++ 运行时 DLL 的副本数

C++ 没有统一的运行时。每个应用都得自己打包一份 C++ 运行库,这是 C++ 生态最直观的特征。全盘扫描 117 个应用目录的结果:

运行时 DLL来源副本数含义
vcruntime140.dllMSVC90MSVC 的 C 运行时
msvcp140.dllMSVC86MSVC 的 C++ 标准库
concrt140.dllMSVC48并发运行时
msvcp140_1.dllMSVC27C++ 标准库附加
ucrtbase.dllWindows29通用 C 运行时
libstdc++-6.dllGCC4GCC 系的 C++ 标准库
libgcc_s_seh-1.dllGCC4GCC 系运行时

90 个 vcruntime140.dll 副本——同一份文件在磁盘上存在 90 次,只是内容因为编译器版本不同而略有差异。这是 C++ 生态的"DLL 地狱",也是它和其他语言最直观的差别。

对比:Go 和 Rust 编译出的程序一个副本都不需要。机器上那个 40 MB 的命令行工具是单文件静态编译,不依赖任何运行时;六个 Rust 桌面应用的目录里也找不到 msvcp140.dll。

为什么引擎层必然是 C/C++

五个原因叠加,任何一个都足以形成锁定:

性能预算

每帧渲染要跑几十万次布局计算。在 60 fps 甚至 120 fps 的预算下,任何带垃圾回收或解释执行的语言都撑不住。

图形接口都是 C

OpenGL、Vulkan、Direct3D、Metal——所有底层图形 API 的接口定义都用 C 写。

系统接口是 C

Win32、POSIX、Cocoa 都是 C ABI。任何语言想调用系统能力,最终都要经过这一层。

ABI 的通用性

C 的 ABI 是唯一跨语言的事实标准。C++ 自己的 ABI 连编译器之间都不一致(MSVC / GCC / Clang 各不相同)。

四十年的自我强化

所有已有的引擎、编解码器、图像库都是 C/C++ 写的,新的只能建在旧的上面。链条从底层到顶层全是 C 系。

最后一条最关键。看看渲染链路:应用层调用自绘引擎(C++)→ 自绘引擎调用 Skia(C++)→ Skia 调用图形 API(C)→ 图形 API 调用显卡驱动(C)。从头到尾没有一处不是 C 系。

唯一的逃生通道:C ABI

有一个概念需要区分清楚:C 语言 和 C ABI 不是一回事。

概念含义能否被替代
C 语言用来写引擎的编程语言✅ Rust / Zig 正在替代
C ABI跨语言调用的接口契约❌ 无法替代,是唯一的通用接口

每个语言都提供了调用 C 的机制,这不是巧合,是生存必需:

语言调 C 的机制本机证据
Dartdart:ffiFlutter 应用的 AOT 产物里含 dart:ffi 引用
Rustextern "C"Rust 桌面应用调用系统 WebView2
JavaJNIIDE 里 jvm.dll 与 CEF 并存
Pythonctypes / C 扩展GenericAgent 是 Python 打包产物
Node.jsN-API / node-gypElectron 的原生模块
Gocgo⚠️ 开了 cgo 就失去纯静态编译优势

C 不是最好的语言,但它是所有语言之间的通用货币。

正在发生的变化

Rust 是四十年来第一个真正威胁 C++ 在引擎层地位的方案。本机数据里能看到这个趋势的边缘:

维度C++Rust
性能顶级相当
内存安全❌ 手动管理✅ 编译期保证
运行时依赖需带 msvcp140.dll 等零依赖
交叉编译麻烦cargo --target
生态成熟度约 40 年约 10 年

本机能观察到的迹象:一个以 Electron 著称的编辑器生态里,出现了纯 Rust 写的新工具;一个原本用 Electron 的网络客户端,其新版换成了 Rust 外壳。这些都是第 4 层向第 3 层渗透的信号。

但第 1 层和第 2 层暂时动不了——Windows 内核还是 C,图形 API 还是 C,而那些巨型引擎(Chromium、Skia、FFmpeg)是几千万行 C++ 的存量资产,没有重写的经济理由。

03五大阵营

把 37 个应用按"浏览器内核从哪来"分类,得到五个阵营。这是全篇的主轴——分类的依据不是"有没有 Chromium",而是 "Chromium 是谁的"。

21
① 自带完整内核
26,969 MB
6
② Rust 外壳
747 MB
4
③ 共享系统内核
2,535 MB
4
④ Qt / C++ 原生
344 MB
2
⑤ 其他内核
875 MB

① 自带完整 Chromium —— 21 个 / 26,969 MB

最大的阵营,占了总体积的 87.7%。共同点是:每个应用都在自己的目录里带一份完整的浏览器内核,不与其他应用共享。

子类数量体积识别标记
Electron118,924 MBapp.asar
CEF37,930 MBlibcef.dll
Chromium 裸核710,115 MBchrome_elf.dll / 编入 exe

三者的技术关系是一个层层封装的链条:

Chromium        完整浏览器项目(Google 维护,几千万行)
    ↓ 包一层 C++ API
CEF             Chromium Embedded Framework(C++ 团队用)
    ↓ 再包一层 Node.js
Electron        JS 团队用

另外一支:
Chromium 裸核     直接拿 Chromium 的构建产物(浏览器本体 / 自研外壳)

越往下封装越多,开发越简单,控制力越弱,但体积都是一样的重。

三个值得单独看的样本

体积最大的那个应用(4,716 MB)——同一个目录里同时存在 Chromium、Electron、Flutter 三套 UI 技术栈。这是历史演进叠出来的,不是设计出来的。

WPS Office(2,649 MB)——浏览器内核被放在 office6\addons\cef\ 下,是作为插件嵌入的。主程序是原生 C++,只在需要渲染网页时才加载 CEF。

VS Code(325 MB)——目录里找不到任何内核标记文件,因为它把 Chromium 编译进了单个 169 MB 的 exe。文件列表干净不代表没有内核。

② Rust 外壳 + 系统内核 —— 6 个 / 747 MB

平均每个 124 MB。这是当前最小的一类桌面应用。

⚠️ 它们不是"不依赖 Chromium"

这类应用的目录里找不到任何 Chromium 标记文件,很容易误判为"不用浏览器内核"。

实际上它们在 Windows 上依赖系统内置的 WebView2,而 WebView2 的实现就是 Chromium(Edge 的内核,Blink + V8)。内核只是不在自己目录里而已。

实测证据:这些应用的主程序 exe 里能搜到 WebView2、EdgeWebView 路径字符串,以及 tauri://localhost、tauri-plugin 这类框架标记。

它们省的是磁盘体积,不是依赖关系。

为什么能省这么多?因为内核从"每个应用一份"变成了"全系统共享一份":

自带内核: 应用A的内核(230MB) + 应用B的内核 + 应用C的内核
共享内核: 应用A + 应用B + 应用C   →   共用系统里那 1 份

本机系统目录里确实只装了一份 WebView2 运行时(约 400–500 MB),但被这 6 个应用,加上另外 4 个非 Rust 的 WebView2 宿主共同使用。

代价:继承系统内核的全部问题

共享意味着策略受制于人,具体包括:

③ 共享系统内核(非 Rust 外壳)—— 4 个 / 2,535 MB

同样用系统 WebView2,但外壳不是 Rust。这四个恰好展示了四种不同的"外壳+内核"组合:

应用类型体积结构
UU远程1,795 MBQt5 壳 + WebView2 界面 + C++ 串流引擎 + 内核驱动
向日葵370 MBMFC 外壳 + Flutter 主体 + WebView2 插件
DBeaver207 MBJava + SWT 界面 + WebView2(内嵌编辑器)
ToDesk163 MBC++ / Qt 主体 + WebView2

第一个样本值得展开:它的目录里有手写的 JS 桥接文件,里面明确定义了四个平台的通信路径——Windows 走 WebView2 的 host objects,iOS 走 webkit.messageHandlers,Android 走自研桥接对象,macOS 走 JS 弹窗(源码里自带一条 Mac onBridge method 的调试日志,看起来是个临时方案)。

这说明它的界面层是一套网页,四端复用;而真正的核心能力(画面采集、编码、传输)全在独立的 C++ 引擎里,完全不经过 WebView。

④ Qt / C++ 原生 —— 4 个 / 344 MB

唯一完全不涉及任何浏览器内核的一类。体积小得惊人:

应用体积框架功能
AnyTXT Searcher217 MBQt5本地文件内容搜索
Snipaste57 MBQt6截图 + 贴图
NcduWin36 MBQt6磁盘占用可视化
webPlugin34 MBQt4浏览器辅助插件

四个加起来 344 MB,不到体积最大的那个应用的十分之一。

值得注意的是其中一个是 Qt4——2010 年前的版本,配着 Python 2 时代的组件。这是存量系统的典型状态:能用就不重写。

⑤ 其他内核 —— 2 个 / 875 MB

微信(872 MB)—— 用 Chromium 的组件,不带完整内核

目录里没有 libcef.dll、没有 app.asar,常规指纹全部落空。

但深挖后发现两个关键文件:一个名叫 mmcronet.dll(Cronet 是 Chromium 的网络栈,Google 把它单独抽出来做成了库),以及一个 412 MB 的 RadiumWMPF.bin,里面含 Blink(Chromium 排版引擎)和 Skia(绘制库)的字符串。

结论:它把 Chromium 拆开只取了需要的部分,没有打包整个浏览器。这种"选择性复用"的形态在商业软件里不罕见,但常规指纹法会完全漏掉它。

Everything(3 MB)—— 最纯粹的样本

整个应用只有 3 MB,目录里只有几个文件,没有任何运行时依赖文件。

这是彻底静态链接的原生 C++ 程序,直接调 Win32 API,把所有能力编进了单个 exe。它和体积最大的那个应用相差 1,572 倍,而两者都是"双击就能用的桌面软件"。

阵营之间的体积对比

① 自带内核
1,284 MB/个
③ 共享(非 Rust)
634 MB/个
⑤ 其他内核
438 MB/个
④ Qt / C++ 原生
86 MB/个
② Rust 外壳
124 MB/个

ⓐ 自带内核的应用平均 1,284 MB,ⓑ Qt 原生应用平均 86 MB。差距 15 倍。

04成本账

Chromium 的性能和兼容性确实是工程胜利,但它的代价也是真实且可量化的。这一节只谈数字。

磁盘:30.40 GB vs 344 MB

30.40 GB
Chromium 相关(33 个应用)
344 MB
完全无关(4 个应用)
90.5×
倍数

单个内核副本的成本是明确的:一个完整 Chromium 的构建产物在 230 MB 以上。本机 Microsoft Edge 的核心 DLL 实测 332 MB(单个文件)。

内存:8.1 GB / 90 个进程

探测系统当前状态,得到这组数字:

473
系统进程总数
31.63 GB
总工作集
8.10 GB
Chromium 系(90 进程)
26%
占总内存比例

其中单独一类(WebView2 宿主进程)就是:

指标值
WebView2 进程数38 个
WebView2 内存合计2,977 MB

单个进程的内存峰值也值得看:

进程工作集说明
IntelliJ IDEA5,549 MB单个进程占 5.5 GB 未查明
Chrome 实例 A460 MB单标签页
VS Code441 MB
Chrome 实例 B436 MB
Chrome 实例 C425 MB

那个 5,549 MB 的值明显偏高(同一 IDE 的正常内存占用通常在 1–2 GB)。但本次分析没有查出原因,所以标为未查明,不做推测。

运行时 DLL:90 个相同文件的副本

DLL副本数含义
vcruntime140.dll90MSVC C 运行时
msvcp140.dll86MSVC C++ 标准库
concrt140.dll48并发运行时
libstdc++-6.dll4GCC C++ 标准库

这些文件本身不大(几百 KB),但副本数量本身就是信息:C++ 没有一个能被所有程序共享的运行时,每个应用只能自带一份。

对比之下,Go 和 Rust 编译的程序不需要任何一份运行时 DLL。

版本堆积

系统里的内核版本分布如下:

安装位置版本
系统 WebView2 运行时152.0.4191.62 / 152.0.4191.66
系统 WebView2 运行时153.0.4234.32 / 153.0.4234.48
Microsoft Edge 本体152.x / 153.x 各两个

同一台机器上并存 4 个不同版本。这不是配置错误,而是内核更新节奏(约每四周一个大版本)与各应用更新节奏不同步的必然结果。

这一点值得一提:自带内核的应用必须自己跟进内核的安全更新。如果某个应用停止维护,它内置的内核版本就会永久停在某个旧版本上,成为一个不会自动修复的安全面。

成本汇总

成本项数值受影响范围
磁盘占用30.40 GB33 个应用
内存占用8.10 GB90 个进程
运行时副本90 个C++ 系全部应用
内核版本数4 个系统级

作为对照:那 4 个 Qt 原生应用、加上那个 3 MB 的搜索工具,合计 347 MB——还不到体积最大那个应用的十三分之一,而它们启动更快、内存占用更低。

05选型归因

看完技术栈分布,自然要问:为什么同一个问题(做一个桌面应用)会分成这么多不同答案?

把 37 个应用按它们的约束条件回头看,会发现三条约束解释了绝大多数选择。

三条约束模型

约束一:延迟敏感 —— 只能上原生

画面采集、编码、传输这类任务,每一毫秒都算在预算里。目标是把端到端延迟压到十几毫秒量级。

这条链路上无法容忍垃圾回收停顿、无法容忍解释执行、无法容忍序列化开销。所以全部由 C++ 写。浏览器内核在这个场景里只能做界面,做不了主力。

代表:远程控制类应用、终端工具、截图工具

约束二:前端团队 + 快速迭代 —— 接受体积

团队是前端背景,会写 JS/TS,不想学新语言。要复杂的富交互界面(编辑器、表格、多面板布局),而且需求变化快。

自带 Chromium 换来的是版本可控 + 渲染完全一致 + 不受系统策略影响。代价是每个应用 300 MB 到 4.5 GB。在“交付速度”优先的团队眼里,这个交易是划算的。

代表:代码编辑器、API 调试工具、网盘、会议软件

约束三:资源敏感 + 近期新项目 —— 共享内核

小团队、单机可能同时开多个同类工具、不在总体积、不愿意为每个应用维护一套内核。

共享系统内核后,单个应用从 300 MB 降到 30–120 MB,内存从几百 MB 降到几十 MB。代价是版本不可控、跨平台不一致、要学一点 Rust。

代表:一批 2026 年新装的小型工具

一张图表看界限

需求特征最佳选择理由
延迟敏感 / 要原生权限Qt、C++、Win32体积最小、启动最快、无中间层
要富交互 UI / 团队是前端Electron、CEF生态成熟、版本可控、只学 JS
要体积小 / 不重复占资源Rust + 系统内核单应用轻,代价是碰不到内核内部
要多端一致 / 摆脱自研框架自绘框架(如 Flutter)一套代码多端、像素级一致
要极致轻量 / 单一功能纯 Win32 静态编译可做到 3 MB,代价是开发成本高

核心案例:一个放弃自研框架的决定

文档 官方声明(原意转述)

向日葵已历 15 年以上,长期依赖一套自研的跨平台 UI 框架支撑多平台的一致表现。但随着产品演进、新功能持续叠加、适配的系统与设备逐渐增加,这套框架“面临维护复杂、成本高等挑战”。

与此同时,新的操作系统生态(含国产化系统)正在兴起,团队决定在新版本中全面引入 Flutter。

这个案例的价值在于:它是本次分析里唯一有官方公开声明的一手选型证据,而不是从二进制推测出来的。

磁盘上的证据与声明完全对应。它的插件目录里并列着三套平台实现:

平台插件目录说明
Windowsoraywebview_windows常规目标
Linuxoraywebview_linux信创系统基础
OpenHarmonyoraywebview_ohos国产化系统适配

同时它的目录里有 flutter_windows.dll(引擎,17.4 MB)和 app.so(Dart 代码的 AOT 机器码,24.6 MB)——确实是 Flutter 在跑。

结论:当自研框架的维护成本超过用新框架重写的成本时,会选择重写。这是“多端一致性”的代价与收益终于算平了。

Flutter 这笔账

Flutter 的“代价”经常被描述得很模糊。实测数据可以说清楚:

组成大小性质
flutter_windows.dll17.4 MB框架固定开销(渲染引擎 + 运行时)
icudtl.dat0.8 MB框架固定开销(国际化数据)
app.so24.6 MB应用代码(AOT 编译产物)
assets/39.8 MB应用资源(图片、字体)
plugins/46.8 MB原生插件

框架固定税约 18 MB。其余的 111 MB 是应用自己的内容——换成其他框架也一样要带。

买到的能力:一套代码多端、像素级视觉一致、功能同步上线、自适应新操作系统、招聘门槛低(会 Dart 就行)。

代价:应用“不像原生”(自绘控件,没有系统原生手感)、无障碍支持弱、文本输入法在桌面端是老大难、Dart 生态远小于 JS。

一个反直觉的事实

“新的”不等于“轻的”

本机数据里,体积最大、内存占用最高、依赖最重的,几乎全是用现代 Web 技术栈的应用。

而体积最小(3 MB)、启动最快、内存最低的那几个,用的是 1990 年代就成熟的 C++ 原生技术。

一组典型对比:VS Code 325 MB,Snipaste 57 MB,Everything 3 MB。

区别不在年代,而在交付的东西不一样:前者交付一个通用浏览器环境,后者交付一个具体功能。

06时间分层

本次分析里最有说服力的一组数据,不在体积上,而在文件时间戳上。

把每个应用目录里最早文件的时间排开,会出现一道干净的技术栈断层。

三代分布

代际时间段技术栈特征典型体积
老一代2024 年前Qt(1998)、Delphi(2008)、CEF(2023)几十 MB
Chromium 直系2024–2025Electron / CEF300 MB – 4.5 GB
共享内核一代2026-04 起Rust + 系统内核13 MB – 668 MB

2026 年 4 月是一道分水岭:此前零个共享内核型应用,此后新装应用里它占多数。

时间线(节选)

按最早文件时间排序,部分应用的时间点:

时间应用类型技术栈体积
1998WindTermQt / C++73 MB
2008EmEditorDelphi + Rust 混合189 MB
2023-06百度网盘CEF + Electron 混合1,276 MB
2024-09IntelliJ IDEACEF + JBR4,005 MB
2025-01VS CodeElectron325 MB
2025-08WPS OfficeCEF(插件)2,649 MB
2025-11SnipasteQt657 MB
2026-04api-switchRust + 系统内核31 MB
2026-07TolariaRust + 系统内核32 MB
2026-10CC GUIRust + 系统内核34 MB

趋势:越新越小

2024–2025 年装
平均 1,597 MB
2026 年装
平均 221 MB

时间越晚,体积越小——7.2 倍的差距。这不是推测,是同一台机器上、同一类软件(都是桌面工具)的实测对比。

需要说明的是:2026 年装的 16 个应用里,也有体积大的(如 ZCode 668 MB、WorkBuddy 831 MB),它们依然是自带内核那一类。下降的是平均水平,不是全部。

为什么会出现这个断层

三个条件在 2025 年底到 2026 年初同时成熟:

① 共享内核方案进入可用状态

系统级的 WebView2 运行时在 Windows 上已普及到“基本都有”的程度。开发者不再需要为“用户系统可能没有内核”而放弃这个路子。

② Rust 的工具链降到了可用门槛

相关的 WebView 绑定库、打包工具、安装器生成器已经成熟。写一个小工具不再需要先懂一大套 Rust 生态。

③ 同时开多个工具的场景变普遍了

当一个人要同时开多个 AI 类的辅助工具时,每个都自带 230 MB 内核、吃掉 300 MB 内存,机器会撑不住。资源约束变成了真实痛点。

而 2024–2025 年装的那批应用,并非“选错了”,而是当时的约束不同:共享内核方案还不够成熟,而自带内核能换来版本可控与跨平台一致性。

一个可以验证的预测

如果这个趋势成立

那么未来新装的轻量工具类应用,应该大多会落在 15–130 MB 区间,而不是 300 MB 以上。

反例也很清楚:需要复杂交互、需要固定内核版本、需要完全一致渲染的应用,依然会自带内核——因为那三个理由并未消失。

07边界与教训

这一节写的是这份分析做不到了什么。放在正文里而不是附注里,是因为这些边界比结论更值得记住。

特征能证明什么,不能证明什么

能证明不能证明例子
存在什么技术 什么是核心 看到 Delphi 指纹,只能说明某个模块用 Delphi 写的——而它可能是更新器,不是主程序
用了哪个框架 为什么这么选 能看出用了 CEF,但看不出是主动选型还是历史遗留
现在装了什么 以前装过什么 卸载残留目录会干扰统计(本次已剔除 6 个空壳目录)
目录里有什么文件 运行时到底加载了什么 内核可能编入单个 exe,也可能延迟加载,静态扫描看不全

一类特殊情形:共享内核让常规指纹失效

目录干净 ≠ 不用浏览器内核

使用系统 WebView2 的应用,目录里一个内核标记文件都没有。如果只用文件指纹法扫描,会得出“它们不用 Chromium”的错误结论。

必须改成读主程序 exe 的字符串才能认出来。这是一个方法上的硬要求,不是可选项。

三个真实误判的完整记录

误判原因修正方式影响面
Haskell 误报 用 3 字母串 ghc 做标记,而它是 x86 指令码加随机字节的巧合 只认长特征串(libraries\base\GHC\List.hs) 6 个应用
Tauri 误报 用 3 字母串 wry 做标记,命中率高得离谱 改用 tauri://localhost 等长串 3 个应用
主程序误判 标记来自目录里的第三方附属 exe,不是主程序 只看快捷方式指向的主程序 2 个应用

一条短字符串黑名单

以下这些长度不足的串不能作为技术栈判据:

  • ghc(Haskell)——x86 指令码巧合
  • wry(Tauri)——三字母,命中率过高
  • Qt(Qt 框架)——同上
  • dart(Dart)——同上
  • nut、bun 等三四字母的运行时名

经验法则:判据串尽量取 8 字符以上,且优先选带路径分隔符或协议前缀的串。

一个被共用而失效的判据

icudtl.dat(ICU 国际化数据文件)曾经是识别 Chromium 的常用特征,但它被多个框架共用:

框架是否带 icudtl.dat
Chromium / Electron / WebView2✅
Flutter✅ 也带

用它做 Chromium 判据,会把所有 Flutter 应用误判为 Chromium 系。正确做法是用 chrome_elf.dll、chrome_100_percent.pak、app.asar、libcef.dll 这些 Chromium 独有的产物名。

看不到的部分

以下是这份分析明确没覆盖的范围,不代表它们不存在:

范围为什么看不到
Web 应用不落在磁盘上,无法扫描
云端 / SaaS 服务同上
绿色版 / 免安装工具可能不在快捷方式登记的目录里
便携驱动器上的软件扫描时未插拔
WASM 运行时内部单个 wasm 文件内部用什么语言写的,从外面看不出来
浏览器扩展是解释执行的 JS,无二进制特征
正在运行的内存镜像只看磁盘,没做进程内存 dump

一处存疑记录

未查明 IntelliJ IDEA 进程占 5.5 GB 内存

同一家族的 IDE 正常内存占用通常在 1–2 GB。本次快照里测到 5,549 MB,且该进程已连续运行约一个月。

可能的方向(均为猜测,未验证):大项目索引未释放、插件内存泄漏、堆参数配置不当、或单纯是长期运行累积。

没有查证就不写结论。这条留在这里的目的是:如果以后要排查,起点已经有了。

方法遗留的两个不足

不足后果改进方向
只扫了目录深度 5–7 层深层嵌套的模块可能漏计改成全深度扫描 + 忽略规则
体积统计含缓存与历史版本单应用体积会偏高区分“程序本体”与“数据/缓存”分别统计

08判据速查

这一节是可以直接拿去用的部分。按技术栈列出识别特征与陷阱,每一条都经过本次分析的实测验证。

主判据表

技术栈识别标记证据强度陷阱
Electronapp.asar强最可靠的判据之一,无已知反例
CEFlibcef.dll强可能与 Electron 共存(同一目录两套都有)
Chromium 裸核chrome_elf.dll
chrome_100_percent.pak
强⚠️ 不要用 icudtl.dat(见下)
编入 exe 的 Chromium主程序 >150 MB 且含内核串中文件列表干净,靠体积异常发现
WebView2 宿主exe 内含 WebView2Loader
EdgeWebView 路径
中必须读 exe 字符串,目录里没标记
Tauritauri://localhost
tauri-plugin
中⚠️ 只扫主程序,不扫附属 exe
Flutterflutter_windows.dll
app.so + icudtl.dat
强引擎可能藏在 4 层以上子目录
QtQt5Core.dll / Qt6Core.dll
QtCore4.dll
强⚠️ 不要用 Qt 三字母
Rustrust_begin_unwind
core::panicking
中静态链接后符号可能极少
GoGo build ID
runtime.gopanic
强单文件静态编译,目录极干净
Javajvm.dll / jbr/强IDE 里常与 CEF 共存
DelphiEmbarcadero
System.pas
中⚠️ 只说明模块语言,不代表主程序
Python 打包_MEIPASS / PyInstaller
python3*.dll
强与上面同理,可能是附属组件
Cronetcronet.dll
mmcronet.dll
中Chromium 只取了网络栈,常规指纹全失效

CDN 与已知陷阱汇总

特征串会被误认为真相
ghcHaskellx86 指令码巧合
wryTauri三字母,命中率过高
icudtl.datChromiumFlutter 也带
v8_context_snapshot.binChromium只说明有 V8,不说明有完整浏览器
WebView2Loader.dll“用了 WebView2”只能说明可能用,需配合主程序串确认
node.exe / node.dllNode 应用可能是打包工具的残留

扫描方法建议

  1. 先按快捷方式确定样本——不要直接扫全盘目录,否则会把卸载残留、系统组件、命令行工具全算进来
  2. 体积统计只用主程序所在目录,不要向上窜层(曾因目录只有两个文件而误把整个父目录 20 GB 算进去)
  3. 先扫指纹文件——快、准、无假阳性
  4. 指纹全空时再读 exe 字符串——这是共享内核型应用的唯一识别途径
  5. 读 exe 时只读主程序,排除附属组件与更新器
  6. 判据串取 8 字符以上,优先带路径或协议前缀
  7. 交叉验证:体积异常小(<150 MB)或异常大(>1.5 GB)的都是值得单独看的样本

一个反直觉的方法结论

“目录里干净”比“目录里东西多”更需要小心。

自带内核的应用会老老实实地把 200 MB 的内核堆在目录里,很好认。而共享内核的应用目录里只有几十 MB,什么都不告诉你——如果只看文件列表,会直接得出错误结论。

本次分析中最容易出错、也最值得反复验证的,就是这个分界。


一句话总结

37 个桌面应用里,33 个最终跑在浏览器内核上(21 个自带、6 个 Rust 共享、4 个其他共享、2 个部分复用),只有 4 个 Qt 原生应用完全绕开了它。

而这 4 个的合计体积(344 MB),不到体积最大那个应用的十三分之一,启动更快、内存更低。

Chromium 赢了工程,代价写在了磁盘和内存上;而那四个“小东西”证明了另一种做法依然可行——只要你不要求它们做同样多的事。