Library / SDK
studyzy/imewlconverter avatar
studyzy/imewlconverter

imewlconverter reads three dictionary formats it refuses to write back

'Shenlan Cizhu Converter' (Deep Blue Lexicon Converter): an open-source, free input-method dictionary conversion program.

10,533 stars717 forksC#GPL-3.0

At a glance

What is it?
imewlconverter is a C# dictionary converter for Chinese input methods, built on .NET 10 with a command line tool and a Windows GUI over shared converter libraries. It moves word lists between Sogou, Rime, Gboard and others, and it will read three binary formats it will not write back.
Who is it for?
Adopt imewlconverter when you keep custom word lists and need them in more than one input method, and build the CLI yourself with the .NET SDK 10 if there is no release archive for your platform. Skip it if you need to write .bdict, .qcel or .qpyd files, if your pipeline redirects stdout from the Windows executable, or if you want a container that reflects your checkout, since the Dockerfile downloads v2.7.0 instead of building your code.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 36 days ago.
What is it written in?
Mainly C#, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • studyzy/imewlconverter10,533 ★ · +174
Star history
Repository2026-09-222026-11-15
studyzy/imewlconverter10.4k10.5k

174 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The Windows executable is a GUI until you pass it an argument

`深蓝词库转换.exe` behaves like two programs sharing one file. Launched with no arguments it opens the graphical interface, which is where batch conversion happens by dragging several dictionary files onto the window or holding Ctrl to select them. Launched with arguments it turns into a command line converter:

bash
深蓝词库转换.exe --help
深蓝词库转换.exe -i scel -o qqpy -O output.txt input.scel

The catch sits in how that output reaches you. The GUI build is a window subsystem program that attaches itself to the parent console, so text shows up in cmd, PowerShell and Windows Terminal. What it cannot do is redirect or pipe. Running `深蓝词库转换.exe --help > help.txt` leaves an empty file behind, and any wrapper script that captures stdout from this executable is capturing nothing at all. For scripting, redirection and CI, the README points at a different artifact, `ImeWlConverterCmd.exe`. Same converter inside, two binaries, and only one of them behaves like a command line tool should.

The format table has three one-way doors: bdict, qcel and qpyd

The format table is where the real limits are. Twenty-one format codes are listed with a file extension, an import column and an export column, and three of them import but refuse to export: `bdict` for Baidu's binary dictionary, `qcel` for the QQ Pinyin cell dictionary, and `qpyd` for its categorized dictionary.

Read that as a one-way street. You can pull a `.bdict` or a `.qcel` out of its home input method and translate it into something else, but you cannot write one back. A dictionary that starts life in Baidu or QQ Pinyin can be read, reshaped and exported, yet it cannot be written back in the `.bdict`, `.qcel` or `.qpyd` format.

Everything text-shaped works both ways instead. `rime` reads and writes `.yaml`, and `sgpy`, `qqpy`, `ggpy`, `bdpy`, `zgpy`, `pyjj`, `libpy`, `fit` and `self` all round-trip through `.txt`, and `plist` through `.plist`. That difference suggests a workflow: keep one of those text formats as the working copy, edit it by hand or with a script, and convert to a binary format only at install time. Only `bdict`, `qcel` and `qpyd` are read-only inputs; other binary formats such as `scel`, `sgpybin` and `gboardbin` can be exported.

The supported list changes with the version, so `--list-formats` prints what the build you actually have understands.

Building from source gives you a DLL, and dotnet stays in front of it

Building from source needs the .NET SDK 10.0 or newer, and the README asks you to confirm that with `dotnet --version` before anything else. The clone, the build and the check are three steps:

bash
# 1. 克隆仓库
git clone https://github.com/studyzy/imewlconverter.git
cd imewlconverter

# 2. 构建命令行工具
dotnet build src/ImeWlConverterCmd

# 3. 验证安装(查看帮助)
dotnet src/ImeWlConverterCmd/bin/Debug/net10.0/ImeWlConverterCmd.dll --help

What lands in the bin directory is a managed DLL rather than a native executable, so `dotnet` remains part of every invocation afterwards. The README offers `dotnet run` as the shorter path, with one detail worth copying exactly: the `--` separator between the project and the converter's own flags is required.

bash
dotnet run --project src/ImeWlConverterCmd -- --help

A Makefile wraps the same work, and `DOTNET_CONFIG` is the knob that switches the build profile.

bash
make build-cmd                    # Debug 模式构建
# 或
DOTNET_CONFIG=Release make build-cmd  # Release 模式构建

The Dockerfile downloads v2.7.0 and runs it on the .NET Core 3.1 image

The Dockerfile at the repository root describes a different product from the one the README tells you to build. It starts from `mcr.microsoft.com/dotnet/core/runtime:3.1`, fetches a fixed release archive over HTTP, unpacks it into the image, and fixes the entry point:

dockerfile
ENV VERSION v2.7.0
ENV INSTALL_DIR /usr/local/imewlconverter
ENV DOWNLOAD_URL https://github.com/studyzy/imewlconverter/releases/download/${VERSION}/imewlconverter_Linux_Mac.tar.gz
ENTRYPOINT ["ImeWlConverterCmd"]
CMD ["-h"]

Two consequences follow. The image never compiles your checkout; it downloads the v2.7.0 artifact, so a container run reproduces the behaviour of that old tag rather than of the code you just edited. And it executes on a .NET Core 3.1 runtime image while the Makefile sets `DOTNET_FRAMEWORK := net10.0` and the README asks for SDK 10.0 or newer, which makes the container a version island rather than a deployment of the current release.

The locale setup is the part worth stealing. The image generates `en_US.UTF-8` and `zh_CN.UTF-8`, writes `LANG="en_US.UTF-8"` into `/etc/default/locale`, defaults `TZ` to `Asia/Shanghai` and symlinks `/etc/localtime`. Dictionary files carrying Chinese text need that locale present. Note also `CMD ["-h"]`: a bare `docker run` prints usage and exits instead of converting anything.

Filters and scel metadata are the only two levers on the output

Once the binary runs, two options shape what comes out of it. The filter flag takes a pipe-separated expression, and the example in the README combines a length window with two removal rules:

bash
dotnet ImeWlConverterCmd.dll -i scel -o ggpy -O output.txt -f "len:1-100|rm:eng|rm:num" input.scel

The second is scel metadata: four long options setting the dictionary number, name, category and description embedded in the file itself.

bash
dotnet ImeWlConverterCmd.dll -i scel -o scel \
  --dict-id 888888 \
  --dict-name "我的词库" \
  --dict-category "IT科技" \
  --dict-description "自定义描述" \
  -O output.scel input.scel

Keep the scope of those four in mind. They touch the metadata block only, and only in formats that carry one, which the README currently names as the Sogou `.scel`. Any field you omit falls back to a default, and the default for the number is randomly generated, so two exports of the same dictionary are not guaranteed to share an identifier. Convert the same source to `rime` or `ggpy` with those flags present and the flags do not affect the output.

Batch conversion is the same command with more input files, and an output ending in `/` is treated as a directory rather than a filename.

v3.0.0 changed the argument grammar and left MIGRATION.md to explain it

Argument style changed once, and it still catches people out. Since v3.0.0 the converter takes GNU-style flags: `-i` for the input format, `-o` for the output format, `-O` for the output file, then the input file. Anything written against the older `-i:scel` form stops working, and the README does not attempt to explain the previous grammar inline. It sends you to `docs/MIGRATION.md` instead.

That is the adoption cost for scripts and CI jobs that wrapped version 2.x. The README points scripts that used the old form to the migration document to find out which argument moved where.

Nine projects, four runtime identifiers, and no Linux publish target

Under the command line front end the code is split into separate projects, and the Makefile lists them: `ImeWlConverter.Core`, `ImeWlConverterCmd`, `ImeWlConverterMac`, `ImeWlConverter.Formats`, `ImeWlConverter.Application`, `ImeWlConverter.CodeData`, `ImeWlConverter.Abstractions`, a Windows shell whose project directory is literally named `IME WL Converter Win`, and `ImeWlConverterCoreTest`.

Runtime identifiers are defined for `osx-arm64`, `osx-x64`, `win-x64` and `win-x86`, and the publish outputs are grouped as `publish/mac-arm64`, `publish/mac-x64`, `publish/win-x64` and `publish/win-x86`. The runtime identifier variables at the top of the Makefile name no Linux target, while the Dockerfile fetches a Linux and macOS archive called `imewlconverter_Linux_Mac.tar.gz`.

The split between the shell projects and the converter libraries is the design in one line: shared code in `ImeWlConverter.Core` and `ImeWlConverter.Formats`, thin front ends on top. GPL-3.0 is the licence that follows, and it is the condition attached to redistributing a modified build.

The last push to the repository was on 2026-10-10. The newest releases are v3.6.0 on 2026-10-08, v3.5.0 on 2026-09-29 and v3.4.3 on 2026-06-29. Nothing is archived.

Editorial conclusion

Adopt imewlconverter when you keep custom word lists and need them in more than one input method, and build the CLI yourself with the .NET SDK 10 if there is no release archive for your platform. Skip it if you need to write .bdict, .qcel or .qpyd files, if your pipeline redirects stdout from the Windows executable, or if you want a container that reflects your checkout, since the Dockerfile downloads v2.7.0 instead of building your code. Before scripting anything against it, check the argument style, because v3.0.0 moved to GNU flags and docs/MIGRATION.md is where the old -i:scel form is explained, and keep a text format such as rime or sgpy as your working copy since those round-trip in both directions.

Frequently asked questions

How do I convert a Sogou scel dictionary with imewlconverter?

Name the input format with `-i`, the output format with `-o`, the destination with `-O`, then the source file last: `dotnet ImeWlConverterCmd.dll -i scel -o ggpy -O output.txt input.scel`. Running `--list-formats` prints the formats the installed build supports.

Which dictionary formats can imewlconverter export back?

`qpyd`, `qcel` and `bdict` are import only. The other listed formats, including `scel`, `sgpy`, `sgpybin`, `qqpy`, `ggpy`, `bdpy`, `rime`, `zgpy`, `pyjj`, `libpy`, `plist`, `fit`, `gboardbin` and `self`, support both import and export.

Why does redirecting the output of the imewlconverter Windows executable give me an empty file?

The GUI executable is a window subsystem program that attaches to the parent console, so its output is visible in the terminal but cannot be redirected or piped. Use `ImeWlConverterCmd.exe` for anything scripted.

Does imewlconverter run on Linux and macOS?

Windows, Linux and macOS are listed as supported. A Makefile builds the command line tool on any of them with `make build-cmd`, or `DOTNET_CONFIG=Release make build-cmd` for a Release build, given the .NET SDK 10.0 or newer.

What happened to the old imewlconverter command line arguments?

Since v3.0.0 the converter uses GNU-style arguments such as `-i scel` instead of the old `-i:scel` form. Scripts built for version 2.x need the mapping in `docs/MIGRATION.md`.

Can imewlconverter read and write a Gboard dictionary?

Yes. The `gboardbin` format code covers the Gboard user_dict_3_3 file with the `.dict` extension, and it is one of the entries marked for both import and export.

Official sources

  1. Issues
  2. License: GPL-3.0
  3. README
  4. Releases
  5. studyzy/imewlconverter on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/studyzy-imewlconverter.svg)](https://hysenlabs.com/projects/studyzy-imewlconverter)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/studyzy-imewlconverter.svg)](https://hysenlabs.com/projects/studyzy-imewlconverter)

Was this useful?