diff --git a/CMakeLists.txt b/CMakeLists.txt
index bd6bf03..f653ae0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,6 +7,7 @@ project(opendspx VERSION 0.0.1.5 LANGUAGES C CXX)
 # ----------------------------------
 option(OPENDSPX_BUILD_STATIC "Build static library" OFF)
 option(OPENDSPX_BUILD_TESTS "Build test cases" OFF)
+option(OPENDSPX_BUILD_INTERPOLATOR "Build interpolator" ON)
 option(OPENDSPX_BUILD_SERIALIZER "Build serializer" ON)
 option(OPENDSPX_BUILD_CONVERTER "Build converter" ON)
 option(OPENDSPX_INSTALL "Install library" ON)
@@ -58,18 +59,23 @@ set(OPENDSPX_INSTALL_NAME ${PROJECT_NAME})
 set(CMAKE_POSITION_INDEPENDENT_CODE on)
 
 set(OPENDSPX_MODEL_TARGET ${PROJECT_NAME}model)
+set(OPENDSPX_INTERPOLATOR_TARGET ${PROJECT_NAME}interpolator)
 set(OPENDSPX_SERIALIZER_TARGET ${PROJECT_NAME}serializer)
 set(OPENDSPX_CONVERTER_TARGET ${PROJECT_NAME}converter)
 set(CURRENT_YEAR)
 string(TIMESTAMP CURRENT_YEAR "%Y")
 
-find_package(QT NAMES Qt6 COMPONENTS Core REQUIRED)
-find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core REQUIRED)
+find_package(nlohmann_json CONFIG REQUIRED)
+find_package(stdcorelib CONFIG REQUIRED)
+if(OPENDSPX_BUILD_SERIALIZER)
+    find_package(zstd CONFIG REQUIRED)
+endif()
+
 if (WIN32)
     include(cmake/winrc.cmake)
 endif()
 
-if (TRUE)
+if(TRUE)
     # Add library
     add_library(${OPENDSPX_MODEL_TARGET} INTERFACE)
     add_library(${PROJECT_NAME}::model ALIAS ${OPENDSPX_MODEL_TARGET})
@@ -83,7 +89,7 @@ if (TRUE)
     )
 
     # Link libraries
-    target_link_libraries(${OPENDSPX_MODEL_TARGET} INTERFACE Qt${QT_VERSION_MAJOR}::Core)
+    target_link_libraries(${OPENDSPX_MODEL_TARGET} INTERFACE nlohmann_json::nlohmann_json)
 
     if (OPENDSPX_INSTALL)
         target_include_directories(${OPENDSPX_MODEL_TARGET} INTERFACE
@@ -96,8 +102,38 @@ if (TRUE)
                 LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" OPTIONAL
                 ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" OPTIONAL
         )
-    endif ()
-endif ()
+    endif()
+endif()
+
+if(OPENDSPX_BUILD_INTERPOLATOR)
+    # Add library
+    add_library(${OPENDSPX_INTERPOLATOR_TARGET} INTERFACE)
+    add_library(${PROJECT_NAME}::interpolator ALIAS ${OPENDSPX_INTERPOLATOR_TARGET})
+
+    # Add features
+    target_compile_features(${OPENDSPX_INTERPOLATOR_TARGET} INTERFACE cxx_std_20 cxx_std_17)
+
+    # Include directories
+    target_include_directories(${OPENDSPX_INTERPOLATOR_TARGET} INTERFACE
+            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    )
+
+    # Link libraries
+    target_link_libraries(${OPENDSPX_INTERPOLATOR_TARGET} INTERFACE nlohmann_json::nlohmann_json)
+
+    if (OPENDSPX_INSTALL)
+        target_include_directories(${OPENDSPX_INTERPOLATOR_TARGET} INTERFACE
+                "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+        )
+
+        install(TARGETS ${OPENDSPX_INTERPOLATOR_TARGET}
+                EXPORT ${OPENDSPX_INSTALL_NAME}Targets
+                RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" OPTIONAL
+                LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" OPTIONAL
+                ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" OPTIONAL
+        )
+    endif()
+endif()
 
 macro(_opendspx_add_library identifier)
     string(TOUPPER "${identifier}" IDENTIFIER)
@@ -126,8 +162,8 @@ macro(_opendspx_add_library identifier)
     )
     target_include_directories(${OPENDSPX_${IDENTIFIER}_TARGET} PRIVATE include/opendspx${identifier})
 
-    target_link_libraries(${OPENDSPX_${IDENTIFIER}_TARGET} PUBLIC Qt${QT_VERSION_MAJOR}::Core)
     target_link_libraries(${OPENDSPX_${IDENTIFIER}_TARGET} PUBLIC ${OPENDSPX_MODEL_TARGET})
+    target_link_libraries(${OPENDSPX_${IDENTIFIER}_TARGET} PRIVATE stdcorelib::stdcorelib)
 
     # Add platform specific
     if (WIN32)
@@ -154,6 +190,7 @@ endmacro()
 
 if (OPENDSPX_BUILD_SERIALIZER)
     _opendspx_add_library(serializer)
+    target_link_libraries(${OPENDSPX_SERIALIZER_TARGET} PRIVATE zstd::libzstd)
 endif()
 
 if (OPENDSPX_BUILD_CONVERTER)
diff --git a/README.md b/README.md
index cfff62c..04a4e78 100644
--- a/README.md
+++ b/README.md
@@ -1,21 +1,145 @@
 # OpenDSPX
 
-DiffScope data exchange format.
+OpenDSPX is a C++20 library for working with the [DSPX format](https://dspx.diffscope.org/).
+It provides four layers:
+
+- `model`: the core DSPX data model and headers
+- `interpolator`: DSPX parameter curve interpolation utilities for evaluating parameter values
+- `serializer`: serialization and deserialization for DSPX files
+- `converter`: DSPX format conversion utilities built on top of the model layer; MIDI is the first supported backend today
 
 ## Requirements
-+ C++ 17
-+ CMake 3.19
-
-## Dependencies
-+ [qastool](https://github.com/SineStriker/qt-json-autogen)
-+ [stdutau](https://github.com/diffscope/stdutau)
-+ [qnrbf](https://github.com/SineStriker/QNrbf)
-    + `QtCore` is required
-+ [QMidi](https://github.com/waddlesplash/QMidi)
-    + `QtCore` is required
-
-## Supported Formats
-
-+ UTAU UST
-+ OpenSVIP
-+ Xiaobin XStudio SVIP (<=2.0)
\ No newline at end of file
+
+Build-time dependencies:
+
+- CMake 3.17 or newer
+- A C++20-capable compiler
+- `nlohmann-json`
+- `stdcorelib`
+- `zstd` for the serializer module
+- `wolf-midi` for the converter module
+
+The project is currently configured for Windows and other CMake-supported platforms.
+
+## Build
+
+Configure and build with CMake:
+
+```bash
+cmake -S . -B build
+cmake --build build
+```
+
+Useful options:
+
+- `OPENDSPX_BUILD_STATIC`: build static libraries instead of shared libraries
+- `OPENDSPX_BUILD_TESTS`: build the test executable
+- `OPENDSPX_BUILD_INTERPOLATOR`: build the interpolator interface library
+- `OPENDSPX_BUILD_SERIALIZER`: build the serializer library
+- `OPENDSPX_BUILD_CONVERTER`: build the converter library
+- `OPENDSPX_INSTALL`: generate install rules and CMake package files
+
+## Using OpenDSPX
+
+### Core model
+
+The core data type is `opendspx::Model`. It currently exposes version `V1` and the associated DSPX content tree.
+
+## Interpolator
+
+The interpolator module is a header-only utility for building and evaluating cubic curves.
+It is useful for DSPX parameter evaluation.
+
+The public API provides helpers for:
+
+- creating a curve from two key points plus reference points
+- creating a curve from only one side of reference data
+- creating a linear interpolator
+- evaluating the resulting curve at any x position
+
+Example:
+
+```cpp
+#include <opendspxinterpolator/interpolator.h>
+
+using opendspx::Interpolator;
+
+int main() {
+	auto curve = Interpolator<double>::createLinear(0.0, 0.0, 1.0, 1.0);
+	double value = curve.evaluate(0.5);
+	(void)value;
+}
+```
+
+### Serialization
+
+Use `opendspx::Serializer` to convert between `Model` and DSPX data streams.
+
+```cpp
+#include <fstream>
+#include <opendspx/model.h>
+#include <opendspxserializer/serializer.h>
+
+using namespace opendspx;
+
+int main() {
+	std::ifstream input("song.dspx", std::ios::binary);
+	SerializationErrorList errors;
+
+	Model model = Serializer::deserialize(input, errors);
+
+	std::ofstream output("song-out.dspx", std::ios::binary);
+	Serializer::serialize(output, model, errors);
+}
+```
+
+`Serializer::serialize` can also write compressed output when the `compress` flag is set to `true`.
+
+### DSPX format conversion
+
+Use `opendspx::Converter` to convert between DSPX data and other formats.
+
+```cpp
+#include <fstream>
+#include <opendspxconverter/midi/midiconverter.h>
+
+using namespace opendspx;
+
+int main() {
+	Model model;
+
+	auto intermediate = MidiConverter::convertDspxToIntermediate(model);
+	std::ofstream midiOutput("output.mid", std::ios::binary);
+	MidiConverter::convertIntermediateToMidi(midiOutput, intermediate);
+
+	MidiConverter::Error error;
+	std::ifstream midiInput("input.mid", std::ios::binary);
+	auto imported = MidiConverter::convertMidiToIntermediate(midiInput, error);
+	if (error != MidiConverter::Error::NoError) {
+		return 1;
+	}
+
+	bool ok = false;
+	Model roundTrip = MidiConverter::convertIntermediateToDspx(imported, &ok);
+	if (!ok) {
+		return 1;
+	}
+
+	(void)roundTrip;
+}
+```
+
+## Project Structure
+
+- `include/opendspx/`: public model headers
+- `include/opendspxinterpolator/`: interpolator API
+- `include/opendspxserializer/`: serializer API
+- `include/opendspxconverter/`: converter API
+- `src/serializer/`: serializer implementation
+- `src/converter/`: converter implementation, currently focused on MIDI
+- `tests/`: usage tests
+
+## License
+
+This project is distributed under the Apache License, Version 2.0, as described in [LICENSE](LICENSE).
+
diff --git a/docs/dspx-example.json b/docs/dspx-example.json
deleted file mode 100644
index 9dacb81..0000000
--- a/docs/dspx-example.json
+++ /dev/null
@@ -1,222 +0,0 @@
-{
-    "version": "1.0.0",
-    "content": {
-        "global": {
-            "author": "作者",
-            "name": "这是一个示例工程",
-            "centShift": 0
-        },
-        "master": {
-            "control": {
-                "gain": 0,
-                "pan": 0,
-                "mute": false
-            }
-        },
-        "timeline": {
-            "timeSignatures": [
-                {
-                    "index": 0,
-                    "numerator": 4,
-                    "denominator": 4
-                }
-            ],
-            "tempos": [
-                {
-                    "pos": 0,
-                    "value": 120
-                }
-            ],
-            "labels": [
-                {
-                    "pos": 1440,
-                    "text": "开始"
-                }
-            ]
-        },
-        "tracks": [
-            {
-                "name": "主音轨",
-                "control": {
-                    "gain": 1,
-                    "pan": 0,
-                    "mute": false,
-                    "solo": false
-                },
-                "clips": [
-                    {
-                        "type": "singing",
-                        "time": {
-                            "start": 0,
-                            "length": 300000,
-                            "clipStart": 1000,
-                            "clipLen": 20000
-                        },
-                        "name": "样式 1",
-                        "control": {
-                            "gain": 1,
-                            "pan": 0,
-                            "mute": false
-                        },
-                        "sources": {
-                            "acoustic": {
-                                "uri": "localhost:2333",
-                                "id": 3,
-                                "name": "夏叶子"
-                            },
-                            "variance": {
-                                "id": 1
-                            }
-                        },
-                        "notes": [
-                            {
-                                "pos": 480,
-                                "length": 480,
-                                "keyNum": 60,
-                                "centShift": 0,
-                                "language": "zh_CN",
-                                "lyric": "拉",
-                                "pronunciation": {
-                                    "original": "la",
-                                    "edited": null
-                                },
-                                "phonemes": {
-                                    "original": [
-                                        {
-                                            "type": "ahead",
-                                            "token": "zh",
-                                            "start": 0
-                                        },
-                                        {
-                                            "type": "normal",
-                                            "token": "u",
-                                            "start": 5
-                                        },
-                                        {
-                                            "type": "final",
-                                            "token": "ang",
-                                            "start": 10
-                                        }
-                                    ],
-                                    "edited": []
-                                },
-                                "vibrato": {
-                                    "start": 0.1,
-                                    "end": 0.8,
-                                    "freq": 5,
-                                    "phase": 0.5,
-                                    "amp": 1.1,
-                                    "offset": 0.1,
-                                    "points": [
-                                        {
-                                            "x": 0.2,
-                                            "y": 1
-                                        },
-                                        {
-                                            "x": 0.8,
-                                            "y": 1
-                                        }
-                                    ]
-                                },
-                                "extra": {
-                                    "render": {
-                                        "seed": 0,
-                                        "speedUp": 100
-                                    }
-                                }
-                            }
-                        ],
-                        "params": {
-                            "pitch": {
-                                "original": [
-                                    {
-                                        "type": "free",
-                                        "start": 100,
-                                        "step": 5,
-                                        "values": [
-                                            114,
-                                            514
-                                        ]
-                                    }
-                                ],
-                                "edited": [
-                                    {
-                                        "type": "anchor",
-                                        "start": 0,
-                                        "nodes": [
-                                            {
-                                                "x": 114,
-                                                "y": 514,
-                                                "interp": "linear"
-                                            },
-                                            {
-                                                "x": 1919,
-                                                "y": 810,
-                                                "interp": "hermite"
-                                            },
-                                            {
-                                                "x": 3330,
-                                                "y": 0,
-                                                "interp": "none"
-                                            }
-                                        ]
-                                    },
-                                    {
-                                        "type": "free",
-                                        "start": 3500,
-                                        "step": 5,
-                                        "values": [
-                                            0,
-                                            1
-                                        ]
-                                    }
-                                ]
-                            },
-                            "energy": {
-                                "original": [],
-                                "edited": [],
-                                "envelope": []
-                            }
-                        }
-                    }
-                ],
-                "color": {
-                    "value": "#3B7FFF"
-                }
-            },
-            {
-                "name": "音乐轨",
-                "control": {
-                    "gain": 1,
-                    "pan": 0,
-                    "mute": false,
-                    "solo": false
-                },
-                "clips": [
-                    {
-                        "type": "audio",
-                        "time": {
-                            "start": 0,
-                            "length": 0,
-                            "clipStart": 1000,
-                            "clipLen": 20000
-                        },
-                        "name": "BGM_1",
-                        "control": {
-                            "gain": 1,
-                            "mute": false
-                        },
-                        "path": "/path/to/bgm.wav"
-                    }
-                ],
-                "color": {
-                    "id": 1
-                }
-            }
-        ]
-    },
-    "workspace": {
-        "core": {},
-        "plugin1": {}
-    }
-}
\ No newline at end of file
diff --git a/docs/dspx-spec.md b/docs/dspx-spec.md
deleted file mode 100644
index 0dfa7e7..0000000
--- a/docs/dspx-spec.md
+++ /dev/null
@@ -1,399 +0,0 @@
-# DSPX 格式简介
-
----
-
-## 根区域
-
-```json
-{
-    "version": "1.0.0",
-    "content": {
-        ...
-    }
-}
-```
-+ `version`：文件版本号
-+ `content`：工程可编辑区域，见下
-
-## 可编辑区域
-
-```json
-{
-    "global": {
-        "name": "New Project",
-        "author": "Admin",
-        "centShift": 0,
-    },
-    "master": {
-        "control": {
-            "gain": 0,
-            "pan": 0,
-            "mute": false
-        }
-    },
-    "timeline": {
-        "timeSignatures": [
-            ...
-        ],
-        "tempos": [
-            ...
-        ],
-        "labels": [
-            ...
-        ]
-    },
-    "tracks": [
-        ...
-    ],
-    "workspace": {
-      ...
-    }
-}
-```
-+ `global`: 元信息
-    + `name`: 工程名
-    + `author`: 作者
-    + `centShift`：全局音分偏移
-+ `master`：总线控制
-    + `control`: 全局主控
-        + `gain`：增益，`double`
-        + `pan`：声像（-1~1），`double`
-        + `mute`：静音
-    <!-- + `loop`: 循环区间
-        + `enabled`: 是否启用
-        + `start`：开始（tick)，`int`
-        + `length`：长度（tick)，`int` -->
-+ `timeline`：时间轴
-    + `timeSignatures`：拍号列表
-    + `tempos`：曲速列表
-    + `labels`：标签；列表
-+ `tracks`：音轨列表
-+ `workspace`：应用程序状态信息
-
-## 拍号
-
-```json
-{
-    "index": 0,
-    "numerator": 4,
-    "denominator": 4
-}
-```
-+ `index`：位置（bar），`int`
-+ `numerator`：分子，`int`
-+ `denominator`：分母，`int`
-
-## 曲速
-
-```json
-{
-    "pos": 0,
-    "value": 120.0
-}
-```
-+ `pos`：位置（tick），`int`
-+ `value`：曲速值，`double`
-
-## 标签
-
-```json
-{
-    "pos": 480,
-    "text": "张三"
-}
-```
-+ `pos`：位置（tick），`int`
-+ `text`：标签内容
-
-## 音轨
-
-```json
-{
-    "name": "主音轨",
-    "control": {
-        "gain": 0,
-        "pan": 0,
-        "mute": false,
-        "solo": false
-    },
-    "clips": [
-        ...
-    ],
-    "color": {
-        ...
-    },
-    "workspace": {
-        ...
-    }
-}
-```
-
-+ `name`：主控
-+ `control`: 音轨主控
-    + `gain`：增益，`double`
-    + `mute`：静音
-    + `solo`：独奏
-+ `clips`：音轨区间列表，暂有音频区间、人声区间
-+ `color`: 音轨颜色信息
-    + 自定义：
-        ```json
-        "value": "#3B7FFF"
-        ```
-    + 内置：
-        ```json
-        "id": "1"
-        ```
-+ `workspace`: 应用程序状态信息
-
-## 音频区间
-
-```json
-{
-    "type": "audio",
-    "time": {
-        "start": 0,
-        "length": 0,
-        "clipStart": 1000,
-        "clipLen": 20000
-    },
-    "name": "BGM_1",
-    "control": {
-        "gain": 1,
-        "pan": 0,
-        "mute": false
-    },
-    "path": "/path/to/bgm.wav",
-    "workspace": {
-        ...
-    }
-}
-```
-
-+ `type`：类型，固定值
-+ `time`: 时间信息
-    + `start`：区间开始（tick），`int`
-    + `length`：固定为0，`int`
-    + `clipStart`：实际开始，相对于区间开始的长度（tick），`int`
-    + `clipLen`：实际长度，相对于实际开始的长度（tick），`int`
-+ `name`：音轨名
-+ `control`：与主控一致
-+ `path`：音频文件所在路径
-+ `workspace`: 应用程序状态信息
-
-## 人声区间
-
-```json
-{
-    "type": "singing",
-    "time": {
-        "start": 0,
-        "length": 300000,
-        "clipStart": 1000,
-        "clipLen": 20000
-    },
-    "name": "样式 1",
-    "control": {
-        "gain": 1,
-        "mute": false
-    },
-    "notes": [
-        ...
-    ],
-    "params": {
-        "pitch": {
-            "original": [
-                ...
-            ],
-            "edited": [
-                ...
-            ]
-        },
-        "energy": {
-            "original": [
-                ...
-            ],
-            "edited": [
-                ...
-            ],
-            "envelope": [
-                ...
-            ]
-        },
-        ...
-    },
-    "sources": {
-        "acoustic": {
-            "model": "mousse",
-            "speaker": {
-                "s1": 30,
-                "s2": 30,
-                "s3": 40
-            }
-        },
-        "pitch": {
-            ...
-        },
-        ...
-    },
-    "workspace": {
-        ...
-    }
-}
-```
-
-+ `type`：类型，固定值
-+ `time`: 时间信息
-    + `length`：区间全长（tick）
-+ `notes`：音符列表
-+ `params`：单线条参数
-    + `pitchDelta`：音高偏差
-        + `original`：自动参数列表
-        + `edited`：已修改的参数列表
-        + `envelope`: 在实参上的包络（音高参数没有这个属性）
-+ `sources`：使用到的模型
-+ `workspace`: 应用程序状态信息
-
-## 音符
-
-```json
-{
-    "pos": 480,
-    "length": 480,
-    "keyNum": 60,
-    "centShift": 0,
-    "language": "zh_CN",
-    "lyric": "拉",
-    "pronunciation": {
-        "original": "la",
-        "edited": null
-    },
-    "phonemes": {
-        "original": [
-            ...
-        ],
-        "edited": [
-            ...
-        ]
-    },
-    "vibrato": {
-        "start": 0.1,
-        "end": 0.8,
-        "freq": 1,
-        "phase": 0.5,
-        "amplitude": 1.1,
-        "offset": 0.1,
-        "points": [
-            {
-                "x": 0.2,
-                "y": 0.8
-            },
-            {
-                "x": 0.8,
-                "y": 1
-            }
-        ]
-    },
-    "workspace": {
-        ...
-    }
-}
-```
-
-+ `pos`：位置（tick），`int`
-+ `length`：长度（tick），`int`
-+ `keyNum`：音阶
-+ `centShift`：音分偏移
-+ `language`: 语言（待定）
-+ `lyric`：歌词
-+ `pronunciation`: 发音
-    `original`：G2P 自动生成的发音
-    `edited`：用户修改后的发音
-+ `phonemes`：音素
-    `original`：自动参数列表
-    `edited`：已修改的参数列表
-+ `vibrato`：颤音
-    + `start`：开始（音符比例），`double`
-    + `end`：结束（音符比例），`double`
-    + `freq`：频率（Hz），`double`
-    + `phase`：相位（0~1），`double`
-    + `amp`：振幅（半音倍率），`double`
-    + `offset`：音高偏移（半音倍率），`double`
-    + `points`：控制点列表，一般只有两个点
-        + `x`：颤音长度比例（0~1），`double`
-        + `y`：颤音振幅比例（0~1），`double`
-+ `workspace`: 应用程序状态信息
-
-## 音素
-
-```json
-{
-    "type": "ahead",
-    "token": "ang",
-    "start": 5
-}
-```
-
-+ `type`：类型，`ahead`、`normal`或`final`
-+ `token`：音素符号
-+ `start`：相对当前音符头的开始时间（ms），`int`
-
-## 单线条参数
-
-### 手绘型
-
-```json
-{
-    "type": "free",
-    "start": 100,
-    "step": 5,
-    "values": [
-        114,
-        514
-    ]
-}
-```
-+ `type`：类型，固定值
-+ `start`：开始（tick）,`int`
-+ `step`：采样步长，固定为5，`int`
-+ `values`：音高坐标（1/100个半音），`int`
-
-### 锚点型
-
-```json
- {
-    "type": "anchor",
-    "start": 100,
-    "nodes": [
-        {
-            "x": 114,
-            "y": 514,
-            "interp": "linear"
-        },
-        {
-            "x": 1919,
-            "y": 810,
-            "interp": "hermite"
-        },
-        {
-            "x": 0,
-            "y": 0,
-            "interp": null
-        }
-    ]
-}
-```
-
-+ `type`：类型，固定值
-+ `start`：开始（tick）,`int`
-+ `nodes`：参数列表
-    + `x`：时间坐标（Tick），`int`
-    + `y`：音高坐标（1/100个半音），`int`
-    + `interp`：插值方式
-
-## 其他
-
-### 单线条参数种类
-
-+ `pitch`：音高曲线参数，`y`的值为绝对音高，如`C4`为`6000`
-+ `energy`: 力度曲线
-+ ...
\ No newline at end of file
diff --git a/include/opendspx/anchornode.h b/include/opendspx/anchornode.h
index 2cfc441..d4f7ad9 100644
--- a/include/opendspx/anchornode.h
+++ b/include/opendspx/anchornode.h
@@ -1,15 +1,15 @@
 #ifndef OPENDSPX_MODEL_ANCHORNODE_H
 #define OPENDSPX_MODEL_ANCHORNODE_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct AnchorNode {
-        enum Interpolation {
+        enum class Interpolation {
             None,
             Linear,
             Hermite,
         };
-        Interpolation interp{None};
+        Interpolation interp{Interpolation::None};
         int x{0};
         int y{0};
     };
diff --git a/include/opendspx/audioclip.h b/include/opendspx/audioclip.h
index 08a74e2..565445d 100644
--- a/include/opendspx/audioclip.h
+++ b/include/opendspx/audioclip.h
@@ -3,16 +3,18 @@
 
 #include <opendspx/clip.h>
 
-namespace QDspx {
+#include <utility>
+
+namespace opendspx {
 
     struct AudioClip : Clip {
-        AudioClip(const QString &name = {}, const BusControl &control = {}, const ClipTime &time = {}, const Workspace &workspace = {}, const QString &path = {})
-            : Clip(Audio, name, control, time, workspace), path(path) {
+        AudioClip(std::string name = {}, const BusControl &control = {}, const ClipTime &time = {}, Workspace workspace = {}, std::string path = {})
+            : Clip(Type::Audio, std::move(name), control, time, std::move(workspace)), path(std::move(path)) {
         }
 
-        QString path;
+        std::string path;
     };
-    using AudioClipRef = QSharedPointer<AudioClip>;
+    using AudioClipRef = std::shared_ptr<AudioClip>;
 
 }
 
diff --git a/include/opendspx/buscontrol.h b/include/opendspx/buscontrol.h
index 2a4eb25..0377e27 100644
--- a/include/opendspx/buscontrol.h
+++ b/include/opendspx/buscontrol.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_BUSCONTROL_H
 #define OPENDSPX_MODEL_BUSCONTROL_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct BusControl {
         double gain{0.0};
diff --git a/include/opendspx/clip.h b/include/opendspx/clip.h
index b5097ad..4b5550f 100644
--- a/include/opendspx/clip.h
+++ b/include/opendspx/clip.h
@@ -1,33 +1,34 @@
 #ifndef OPENDSPX_MODEL_CLIP_H
 #define OPENDSPX_MODEL_CLIP_H
 
-#include <QSharedPointer>
-#include <QString>
+#include <memory>
+#include <string>
+#include <utility>
 
 #include <opendspx/buscontrol.h>
 #include <opendspx/cliptime.h>
 #include <opendspx/workspace.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Clip {
-        enum Type {
+        enum class Type {
             Audio,
             Singing,
         };
         Type type;
-        QString name;
+        std::string name;
         BusControl control;
         ClipTime time;
         Workspace workspace;
 
     protected:
-        Clip(Type type, const QString &name = {}, const BusControl &control = {}, const ClipTime &time = {}, const Workspace &workspace = {})
-            : type(type), name(name), control(control), time(time), workspace(workspace) {
+        Clip(Type type, std::string name = {}, const BusControl &control = {}, const ClipTime &time = {}, Workspace workspace = {})
+            : type(type), name(std::move(name)), control(control), time(time), workspace(std::move(workspace)) {
         }
     };
 
-    using ClipRef = QSharedPointer<Clip>;
+    using ClipRef = std::shared_ptr<Clip>;
 
 }
 
diff --git a/include/opendspx/cliptime.h b/include/opendspx/cliptime.h
index e9801f2..3916ad0 100644
--- a/include/opendspx/cliptime.h
+++ b/include/opendspx/cliptime.h
@@ -1,10 +1,10 @@
 #ifndef OPENDSPX_MODEL_CLIPTIME_H
 #define OPENDSPX_MODEL_CLIPTIME_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct ClipTime {
-        int start{0};
+        int pos{0};
         int length{0};
         int clipStart{0};
         int clipLen{0};
diff --git a/include/opendspx/content.h b/include/opendspx/content.h
index 5d579d1..6d7d23c 100644
--- a/include/opendspx/content.h
+++ b/include/opendspx/content.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_CONTENT_H
 #define OPENDSPX_MODEL_CONTENT_H
 
-#include <QList>
+#include <vector>
 
 #include <opendspx/global.h>
 #include <opendspx/master.h>
@@ -9,13 +9,13 @@
 #include <opendspx/track.h>
 #include <opendspx/workspace.h>
 
-namespace QDspx{
+namespace opendspx{
 
     struct Content {
         Global global;
         Master master;
         Timeline timeline;
-        QList<Track> tracks;
+        std::vector<Track> tracks;
         Workspace workspace;
     };
 
diff --git a/include/opendspx/controlpoint.h b/include/opendspx/controlpoint.h
index 0e02d15..70dc65f 100644
--- a/include/opendspx/controlpoint.h
+++ b/include/opendspx/controlpoint.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_CONTROLPOINT_H
 #define OPENDSPX_MODEL_CONTROLPOINT_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct ControlPoint {
         double x{0.0};
diff --git a/include/opendspx/dynamicmixinganchor.h b/include/opendspx/dynamicmixinganchor.h
new file mode 100644
index 0000000..7d7f17f
--- /dev/null
+++ b/include/opendspx/dynamicmixinganchor.h
@@ -0,0 +1,15 @@
+#ifndef OPENDSPX_MODEL_DYNAMICMIXINGANCHOR_H
+#define OPENDSPX_MODEL_DYNAMICMIXINGANCHOR_H
+
+#include <opendspx/sourcemixingratio.h>
+
+namespace opendspx {
+
+    struct DynamicMixingAnchor {
+        int pos{0};
+        SourceMixingRatio ratio;
+    };
+
+}
+
+#endif //OPENDSPX_MODEL_DYNAMICMIXINGANCHOR_H
diff --git a/include/opendspx/global.h b/include/opendspx/global.h
index 3606e7d..dc0103f 100644
--- a/include/opendspx/global.h
+++ b/include/opendspx/global.h
@@ -1,16 +1,16 @@
 #ifndef OPENDSPX_MODEL_GLOBAL_H
 #define OPENDSPX_MODEL_GLOBAL_H
 
-#include <QString>
+#include <string>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Global {
-        QString author;
-        QString name;
+        std::string author;
+        std::string name;
         int centShift{0};
-        QString editorId;
-        QString editorName;
+        std::string editorId;
+        std::string editorName;
     };
 
 }
diff --git a/include/opendspx/label.h b/include/opendspx/label.h
index 17746e8..bbdd95a 100644
--- a/include/opendspx/label.h
+++ b/include/opendspx/label.h
@@ -1,13 +1,13 @@
 #ifndef OPENDSPX_MODEL_LABEL_H
 #define OPENDSPX_MODEL_LABEL_H
 
-#include <QString>
+#include <string>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Label {
         int pos{0};
-        QString text;
+        std::string text;
     };
 
 }
diff --git a/include/opendspx/master.h b/include/opendspx/master.h
index eb3e404..19eb022 100644
--- a/include/opendspx/master.h
+++ b/include/opendspx/master.h
@@ -3,7 +3,7 @@
 
 #include <opendspx/buscontrol.h>
 
-namespace QDspx{
+namespace opendspx{
 
     struct Master {
         BusControl control;
diff --git a/include/opendspx/mixedsinger.h b/include/opendspx/mixedsinger.h
new file mode 100644
index 0000000..a2f89a1
--- /dev/null
+++ b/include/opendspx/mixedsinger.h
@@ -0,0 +1,25 @@
+#ifndef OPENDSPX_MODEL_MIXEDSINGER_H
+#define OPENDSPX_MODEL_MIXEDSINGER_H
+
+#include <utility>
+#include <vector>
+
+#include <opendspx/singer.h>
+#include <opendspx/sourcemixingratio.h>
+
+namespace opendspx {
+
+    struct MixedSinger : Singer {
+        MixedSinger(std::vector<SingerRef> singers = {}, SourceMixingRatio ratio = {}, nlohmann::json extra = {}, Workspace workspace = {})
+            : Singer(Type::Mixed, std::move(extra), std::move(workspace)), singers(std::move(singers)), ratio(std::move(ratio)) {
+        }
+
+        std::vector<SingerRef> singers;
+        SourceMixingRatio ratio;
+    };
+
+    using MixedSingerRef = std::shared_ptr<MixedSinger>;
+
+}
+
+#endif //OPENDSPX_MODEL_MIXEDSINGER_H
diff --git a/include/opendspx/model.h b/include/opendspx/model.h
index c447ef0..c6a908c 100644
--- a/include/opendspx/model.h
+++ b/include/opendspx/model.h
@@ -3,13 +3,13 @@
 
 #include <opendspx/content.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Model {
-        enum Version {
+        enum class Version {
             V1,
         };
-        Version version{V1};
+        Version version{Version::V1};
         Content content;
     };
 
diff --git a/include/opendspx/note.h b/include/opendspx/note.h
index 78ddb4b..cb697cf 100644
--- a/include/opendspx/note.h
+++ b/include/opendspx/note.h
@@ -1,22 +1,22 @@
 #ifndef OPENDSPX_MODEL_NOTE_H
 #define OPENDSPX_MODEL_NOTE_H
 
-#include <QString>
+#include <string>
 
 #include <opendspx/phonemes.h>
 #include <opendspx/pronunciation.h>
 #include <opendspx/vibrato.h>
 #include <opendspx/workspace.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Note {
         int pos{0};
         int length{0};
         int keyNum{0};
         int centShift{0};
-        QString language;
-        QString lyric;
+        std::string language;
+        std::string lyric;
         Pronunciation pronunciation;
         Phonemes phonemes;
         Vibrato vibrato;
diff --git a/include/opendspx/param.h b/include/opendspx/param.h
index c079b0d..b1af284 100644
--- a/include/opendspx/param.h
+++ b/include/opendspx/param.h
@@ -1,18 +1,18 @@
 #ifndef OPENDSPX_MODEL_PARAM_H
 #define OPENDSPX_MODEL_PARAM_H
 
-#include <QList>
+#include <vector>
 
 #include <opendspx/paramcurve.h>
 #include <opendspx/paramcurveanchor.h>
 #include <opendspx/paramcurvefree.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Param {
-        QList<ParamCurveRef> original;
-        QList<ParamCurveRef> transform;
-        QList<ParamCurveRef> edited;
+        std::vector<ParamCurveRef> original;
+        std::vector<ParamCurveRef> transform;
+        std::vector<ParamCurveRef> edited;
     };
 
 }
diff --git a/include/opendspx/paramcurve.h b/include/opendspx/paramcurve.h
index 3ebad2d..2339164 100644
--- a/include/opendspx/paramcurve.h
+++ b/include/opendspx/paramcurve.h
@@ -1,9 +1,9 @@
 #ifndef OPENDSPX_MODEL_PARAMCURVE_H
 #define OPENDSPX_MODEL_PARAMCURVE_H
 
-#include <QSharedPointer>
+#include <memory>
 
-namespace QDspx {
+namespace opendspx {
 
     struct ParamCurve {
         enum Type {
@@ -19,7 +19,7 @@ namespace QDspx {
         }
     };
 
-    using ParamCurveRef = QSharedPointer<ParamCurve>;
+    using ParamCurveRef = std::shared_ptr<ParamCurve>;
 
 }
 
diff --git a/include/opendspx/paramcurveanchor.h b/include/opendspx/paramcurveanchor.h
index 74c59c4..3dd32e0 100644
--- a/include/opendspx/paramcurveanchor.h
+++ b/include/opendspx/paramcurveanchor.h
@@ -1,22 +1,23 @@
 #ifndef OPENDSPX_MODEL_PARAMCURVEANCHOR_H
 #define OPENDSPX_MODEL_PARAMCURVEANCHOR_H
 
-#include <QList>
+#include <vector>
+#include <utility>
 
 #include <opendspx/paramcurve.h>
 #include <opendspx/anchornode.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct ParamCurveAnchor : ParamCurve {
-        ParamCurveAnchor(int start = 0, const QList<AnchorNode> &nodes = {})
-            : ParamCurve(Anchor, start), nodes(nodes) {
+        ParamCurveAnchor(int start = 0, std::vector<AnchorNode> nodes = {})
+            : ParamCurve(Anchor, start), nodes(std::move(nodes)) {
         }
 
-        QList<AnchorNode> nodes;
+        std::vector<AnchorNode> nodes;
     };
     
-    using ParamCurveAnchorRef = QSharedPointer<ParamCurveAnchor>;
+    using ParamCurveAnchorRef = std::shared_ptr<ParamCurveAnchor>;
 
 }
 
diff --git a/include/opendspx/paramcurvefree.h b/include/opendspx/paramcurvefree.h
index dd09867..2d108c5 100644
--- a/include/opendspx/paramcurvefree.h
+++ b/include/opendspx/paramcurvefree.h
@@ -1,22 +1,23 @@
 #ifndef OPENDSPX_MODEL_PARAMCURVEFREE_H
 #define OPENDSPX_MODEL_PARAMCURVEFREE_H
 
-#include <QList>
+#include <vector>
+#include <utility>
 
 #include <opendspx/paramcurve.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct ParamCurveFree : ParamCurve {
-        ParamCurveFree(int start = 0, int step = 5, const QList<int> &values = {})
-            : ParamCurve(Free, start), step(step), values(values) {
+        ParamCurveFree(int start = 0, int step = 5, std::vector<int> values = {})
+            : ParamCurve(Free, start), step(step), values(std::move(values)) {
         }
 
         int step;
-        QList<int> values;
+        std::vector<int> values;
     };
     
-    using ParamCurveFreeRef = QSharedPointer<ParamCurveFree>;
+    using ParamCurveFreeRef = std::shared_ptr<ParamCurveFree>;
 
 }
 
diff --git a/include/opendspx/params.h b/include/opendspx/params.h
index 5856ea7..e6d599f 100644
--- a/include/opendspx/params.h
+++ b/include/opendspx/params.h
@@ -1,14 +1,17 @@
 #ifndef OPENDSPX_MODEL_PARAMS_H
 #define OPENDSPX_MODEL_PARAMS_H
 
-#include <QMap>
-#include <QString>
+#include <map>
+#include <string>
 
 #include <opendspx/param.h>
 
-namespace QDspx {
+namespace opendspx {
 
-    using Params = QMap<QString, Param>;
+    class Params : public std::map<std::string, Param> {
+    public:
+        using std::map<std::string, Param>::map;
+    };
 
 }
 
diff --git a/include/opendspx/phoneme.h b/include/opendspx/phoneme.h
index 8c41dab..dfc86ad 100644
--- a/include/opendspx/phoneme.h
+++ b/include/opendspx/phoneme.h
@@ -1,13 +1,13 @@
 #ifndef OPENDSPX_MODEL_PHONEME_H
 #define OPENDSPX_MODEL_PHONEME_H
 
-#include <QString>
+#include <string>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Phoneme {
-        QString language;
-        QString token;
+        std::string language;
+        std::string token;
         int start{0};
         bool onset{false};
     };
diff --git a/include/opendspx/phonemes.h b/include/opendspx/phonemes.h
index 721a64a..1484c9d 100644
--- a/include/opendspx/phonemes.h
+++ b/include/opendspx/phonemes.h
@@ -1,15 +1,15 @@
 #ifndef OPENDSPX_MODEL_PHONEMES_H
 #define OPENDSPX_MODEL_PHONEMES_H
 
-#include <QList>
+#include <vector>
 
 #include <opendspx/phoneme.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Phonemes {
-        QList<Phoneme> original;
-        QList<Phoneme> edited;
+        std::vector<Phoneme> original;
+        std::vector<Phoneme> edited;
     };
 
 }
diff --git a/include/opendspx/pronunciation.h b/include/opendspx/pronunciation.h
index 8f49469..c4c5723 100644
--- a/include/opendspx/pronunciation.h
+++ b/include/opendspx/pronunciation.h
@@ -1,13 +1,13 @@
 #ifndef OPENDSPX_MODEL_PRONUNCIATION_H
 #define OPENDSPX_MODEL_PRONUNCIATION_H
 
-#include <QString>
+#include <string>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Pronunciation {
-        QString original;
-        QString edited;
+        std::string original;
+        std::string edited;
     };
 
 }
diff --git a/include/opendspx/singer.h b/include/opendspx/singer.h
new file mode 100644
index 0000000..75b1fcd
--- /dev/null
+++ b/include/opendspx/singer.h
@@ -0,0 +1,32 @@
+#ifndef OPENDSPX_MODEL_SINGER_H
+#define OPENDSPX_MODEL_SINGER_H
+
+#include <memory>
+#include <utility>
+
+#include <nlohmann/json.hpp>
+
+#include <opendspx/workspace.h>
+
+namespace opendspx {
+
+    struct Singer {
+        enum class Type {
+            Single,
+            Mixed,
+        };
+        Type type;
+        nlohmann::json extra;
+        Workspace workspace;
+
+    protected:
+        Singer(Type type, nlohmann::json extra = {}, Workspace workspace = {})
+            : type(type), extra(std::move(extra)), workspace(std::move(workspace)) {
+        }
+    };
+
+    using SingerRef = std::shared_ptr<Singer>;
+
+}
+
+#endif //OPENDSPX_MODEL_SINGER_H
diff --git a/include/opendspx/singingclip.h b/include/opendspx/singingclip.h
index e220532..3d308f6 100644
--- a/include/opendspx/singingclip.h
+++ b/include/opendspx/singingclip.h
@@ -1,26 +1,28 @@
 #ifndef OPENDSPX_MODEL_SINGINGCLIP_H
 #define OPENDSPX_MODEL_SINGINGCLIP_H
 
-#include <QList>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include <opendspx/clip.h>
 #include <opendspx/note.h>
 #include <opendspx/params.h>
 #include <opendspx/sources.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct SingingClip : Clip {
-        SingingClip(const QString &name = {}, const BusControl &control = {}, const ClipTime &time = {}, const Workspace &workspace = {}, const QList<Note> &notes = {}, const Params &params = {}, const Sources &sources = {})
-            : Clip(Singing, name, control, time, workspace), notes(notes), params(params), sources(sources) {
+        SingingClip(const std::string &name = {}, const BusControl &control = {}, const ClipTime &time = {}, const Workspace &workspace = {}, std::vector<Note> notes = {}, const Params &params = {}, std::optional<Sources> sources = {})
+            : Clip(Type::Singing, name, control, time, workspace), notes(std::move(notes)), params(params), sources(std::move(sources)) {
         }
 
-        QList<Note> notes;
+        std::vector<Note> notes;
         Params params;
-        Sources sources;
+        std::optional<Sources> sources;
     };
     
-    using SingingClipRef = QSharedPointer<SingingClip>;
+    using SingingClipRef = std::shared_ptr<SingingClip>;
 
 }
 
diff --git a/include/opendspx/singlesinger.h b/include/opendspx/singlesinger.h
new file mode 100644
index 0000000..6f1f956
--- /dev/null
+++ b/include/opendspx/singlesinger.h
@@ -0,0 +1,23 @@
+#ifndef OPENDSPX_MODEL_SINGLESINGER_H
+#define OPENDSPX_MODEL_SINGLESINGER_H
+
+#include <string>
+#include <utility>
+
+#include <opendspx/singer.h>
+
+namespace opendspx {
+
+    struct SingleSinger : Singer {
+        SingleSinger(std::string id = {}, nlohmann::json extra = {}, Workspace workspace = {})
+            : Singer(Type::Single, std::move(extra), std::move(workspace)), id(std::move(id)) {
+        }
+
+        std::string id;
+    };
+
+    using SingleSingerRef = std::shared_ptr<SingleSinger>;
+
+}
+
+#endif //OPENDSPX_MODEL_SINGLESINGER_H
diff --git a/include/opendspx/sourcemixingratio.h b/include/opendspx/sourcemixingratio.h
new file mode 100644
index 0000000..ba46bea
--- /dev/null
+++ b/include/opendspx/sourcemixingratio.h
@@ -0,0 +1,20 @@
+#ifndef OPENDSPX_MODEL_SOURCEMIXINGRATIO_H
+#define OPENDSPX_MODEL_SOURCEMIXINGRATIO_H
+
+#include <algorithm>
+#include <vector>
+
+namespace opendspx {
+
+    class SourceMixingRatio : public std::vector<double> {
+    public:
+        using std::vector<double>::vector;
+
+        [[nodiscard]] constexpr bool valid() const {
+            return std::ranges::all_of(*this, [](double x) { return x >= 0 && x <= 1; }) && std::reduce(begin(), end(), 0.0) <= 1.0;
+        }
+    };
+
+}
+
+#endif //OPENDSPX_MODEL_SOURCEMIXINGRATIO_H
diff --git a/include/opendspx/sources.h b/include/opendspx/sources.h
index a675e06..ad64820 100644
--- a/include/opendspx/sources.h
+++ b/include/opendspx/sources.h
@@ -1,13 +1,21 @@
 #ifndef OPENDSPX_MODEL_SOURCES_H
 #define OPENDSPX_MODEL_SOURCES_H
 
-#include <QMap>
-#include <QJsonObject>
-#include <QString>
+#include <string>
+#include <vector>
 
-namespace QDspx {
+#include <opendspx/dynamicmixinganchor.h>
+#include <opendspx/singer.h>
+#include <opendspx/singlesinger.h>
+#include <opendspx/mixedsinger.h>
 
-    using Sources = QMap<QString, QJsonObject>;
+namespace opendspx {
+
+    struct Sources {
+        std::string category;
+        std::vector<DynamicMixingAnchor> mix;
+        std::vector<SingerRef> singers;
+    };
 
 }
 
diff --git a/include/opendspx/tempo.h b/include/opendspx/tempo.h
index c2fb3da..9de0fdc 100644
--- a/include/opendspx/tempo.h
+++ b/include/opendspx/tempo.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_TEMPO_H
 #define OPENDSPX_MODEL_TEMPO_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct Tempo {
         int pos{0};
diff --git a/include/opendspx/timeline.h b/include/opendspx/timeline.h
index c176ea9..8ad4307 100644
--- a/include/opendspx/timeline.h
+++ b/include/opendspx/timeline.h
@@ -1,18 +1,18 @@
 #ifndef OPENDSPX_MODEL_TIMELINE_H
 #define OPENDSPX_MODEL_TIMELINE_H
 
-#include <QList>
+#include <vector>
 
 #include <opendspx/label.h>
 #include <opendspx/tempo.h>
 #include <opendspx/timesignature.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Timeline {
-        QList<Label> labels;
-        QList<Tempo> tempos;
-        QList<TimeSignature> timeSignatures;
+        std::vector<Label> labels;
+        std::vector<Tempo> tempos;
+        std::vector<TimeSignature> timeSignatures;
     };
 
 }
diff --git a/include/opendspx/timesignature.h b/include/opendspx/timesignature.h
index 80b6420..a000f3e 100644
--- a/include/opendspx/timesignature.h
+++ b/include/opendspx/timesignature.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_TIMESIGNATURE_H
 #define OPENDSPX_MODEL_TIMESIGNATURE_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct TimeSignature {
         int index{0};
diff --git a/include/opendspx/track.h b/include/opendspx/track.h
index 68661cf..cea2f71 100644
--- a/include/opendspx/track.h
+++ b/include/opendspx/track.h
@@ -1,8 +1,8 @@
 #ifndef OPENDSPX_MODEL_TRACK_H
 #define OPENDSPX_MODEL_TRACK_H
 
-#include <QList>
-#include <QString>
+#include <vector>
+#include <string>
 
 #include <opendspx/audioclip.h>
 #include <opendspx/clip.h>
@@ -10,12 +10,12 @@
 #include <opendspx/trackcontrol.h>
 #include <opendspx/workspace.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Track {
-        QString name;
+        std::string name;
         TrackControl control;
-        QList<ClipRef> clips;
+        std::vector<ClipRef> clips;
         Workspace workspace;
     };
 
diff --git a/include/opendspx/trackcontrol.h b/include/opendspx/trackcontrol.h
index 8f1fb18..ac53230 100644
--- a/include/opendspx/trackcontrol.h
+++ b/include/opendspx/trackcontrol.h
@@ -1,7 +1,7 @@
 #ifndef OPENDSPX_MODEL_TRACKCONTROL_H
 #define OPENDSPX_MODEL_TRACKCONTROL_H
 
-namespace QDspx {
+namespace opendspx {
 
     struct TrackControl {
         double gain{0.0};
diff --git a/include/opendspx/vibrato.h b/include/opendspx/vibrato.h
index a14cb4e..c66e4f5 100644
--- a/include/opendspx/vibrato.h
+++ b/include/opendspx/vibrato.h
@@ -3,7 +3,7 @@
 
 #include <opendspx/vibratopoints.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Vibrato {
         double start{0.0};
diff --git a/include/opendspx/vibratopoints.h b/include/opendspx/vibratopoints.h
index 534886e..3f19888 100644
--- a/include/opendspx/vibratopoints.h
+++ b/include/opendspx/vibratopoints.h
@@ -1,15 +1,15 @@
 #ifndef OPENDSPX_MODEL_VIBRATOPOINTS_H
 #define OPENDSPX_MODEL_VIBRATOPOINTS_H
 
-#include <QList>
+#include <vector>
 
 #include <opendspx/controlpoint.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct VibratoPoints {
-        QList<ControlPoint> amp;
-        QList<ControlPoint> freq;
+        std::vector<ControlPoint> amp;
+        std::vector<ControlPoint> freq;
     };
 
 }
diff --git a/include/opendspx/workspace.h b/include/opendspx/workspace.h
index c1e5132..cebd57e 100644
--- a/include/opendspx/workspace.h
+++ b/include/opendspx/workspace.h
@@ -1,12 +1,17 @@
 #ifndef OPENDSPX_MODEL_WORKSPACE_H
 #define OPENDSPX_MODEL_WORKSPACE_H
 
-#include <QMap>
-#include <QJsonObject>
+#include <map>
+#include <string>
 
-namespace QDspx{
+#include <nlohmann/json.hpp>
 
-    using Workspace = QMap<QString, QJsonObject>;
+namespace opendspx{
+
+    class Workspace : public std::map<std::string, nlohmann::json> {
+    public:
+        using std::map<std::string, nlohmann::json>::map;
+    };
 
 }
 
diff --git a/include/opendspxconverter/midi/midiconverter.h b/include/opendspxconverter/midi/midiconverter.h
index b1f7d58..727d4d1 100644
--- a/include/opendspxconverter/midi/midiconverter.h
+++ b/include/opendspxconverter/midi/midiconverter.h
@@ -1,11 +1,13 @@
 #ifndef OPENDSPX_CONVERTER_MIDICONVERTER_H
 #define OPENDSPX_CONVERTER_MIDICONVERTER_H
 
+#include <iosfwd>
 #include <functional>
+#include <string>
 
 #include <opendspxconverter/opendspxconverterglobal.h>
 
-namespace QDspx {
+namespace opendspx {
 
     struct Model;
     class MidiIntermediateData;
@@ -22,19 +24,20 @@ namespace QDspx {
         struct ConvertMidiToIntermediateOption {
             bool separateChannels = true;
         };
-        static MidiIntermediateData convertMidiToIntermediate(const QByteArray &midiData, Error &error, ConvertMidiToIntermediateOption option = {true});
+        static MidiIntermediateData convertMidiToIntermediate(std::istream &in, Error &error, ConvertMidiToIntermediateOption option = {true});
 
         static Model convertIntermediateToDspx(const MidiIntermediateData &midiData, bool *ok = nullptr);
-        static Model convertIntermediateToDspx(const MidiIntermediateData &midiData, const std::function<QString(const QByteArray &)> &decodeText, bool *ok = nullptr);
+
+        static Model convertIntermediateToDspx(const MidiIntermediateData &midiData, const std::function<std::string(const std::string &)> &decodeText, bool *ok = nullptr);
 
         struct ConvertDspxToIntermediateOption {
             int resolution = 480;
             bool separateClips = false;
         };
         static MidiIntermediateData convertDspxToIntermediate(const Model &model, ConvertDspxToIntermediateOption option = {480, false});
-        static MidiIntermediateData convertDspxToIntermediate(const Model &model, const std::function<QByteArray(const QString &)> &encodeText, ConvertDspxToIntermediateOption option = {480, false});
+        static MidiIntermediateData convertDspxToIntermediate(const Model &model, const std::function<std::string(const std::string &)> &encodeText, ConvertDspxToIntermediateOption option = {480, false});
 
-        static QByteArray convertIntermediateToMidi(const MidiIntermediateData &midiData);
+        static void convertIntermediateToMidi(std::ostream &out, const MidiIntermediateData &midiData);
 
     };
 
diff --git a/include/opendspxconverter/midi/midiintermediatedata.h b/include/opendspxconverter/midi/midiintermediatedata.h
index dae3e25..000700f 100644
--- a/include/opendspxconverter/midi/midiintermediatedata.h
+++ b/include/opendspxconverter/midi/midiintermediatedata.h
@@ -2,11 +2,10 @@
 #define OPENDSPX_CONVERTER_MIDIINTERMEDIATEDATA_H
 
 #include <algorithm>
+#include <string>
+#include <vector>
 
-#include <QByteArray>
-#include <QList>
-
-namespace QDspx {
+namespace opendspx {
 
     class MidiIntermediateData {
     public:
@@ -24,26 +23,26 @@ namespace QDspx {
 
         struct Marker {
             int tick;
-            QByteArray text;
+            std::string text;
         };
 
         struct Note {
             int noteOnTick;
             int length;
             int key;
-            QByteArray lyric;
+            std::string lyric;
         };
 
         struct Track {
-            QByteArray title;
-            QList<Note> notes;
+            std::string title;
+            std::vector<Note> notes;
             int channelIndex;
             int endTick;
         };
 
         MidiIntermediateData() = default;
 
-        MidiIntermediateData(int resolution, QList<Tempo> tempos, QList<TimeSignature> timeSignatures, QList<Marker> markers, QList<Track> tracks)
+        MidiIntermediateData(int resolution, std::vector<Tempo> tempos, std::vector<TimeSignature> timeSignatures, std::vector<Marker> markers, std::vector<Track> tracks)
             : m_resolution(resolution),
               m_tempos(std::move(tempos)),
               m_timeSignatures(std::move(timeSignatures)),
@@ -55,19 +54,19 @@ namespace QDspx {
             return m_resolution;
         }
 
-        QList<Tempo> tempos() const {
+        std::vector<Tempo> tempos() const {
             return m_tempos;
         }
 
-        QList<TimeSignature> timeSignatures() const {
+        std::vector<TimeSignature> timeSignatures() const {
             return m_timeSignatures;
         }
 
-        QList<Marker> markers() const {
+        std::vector<Marker> markers() const {
             return m_markers;
         }
 
-        QList<Track> tracks() const {
+        std::vector<Track> tracks() const {
             return m_tracks;
         }
 
@@ -93,10 +92,10 @@ namespace QDspx {
 
     private:
         int m_resolution{};
-        QList<Tempo> m_tempos;
-        QList<TimeSignature> m_timeSignatures;
-        QList<Marker> m_markers;
-        QList<Track> m_tracks;
+        std::vector<Tempo> m_tempos;
+        std::vector<TimeSignature> m_timeSignatures;
+        std::vector<Marker> m_markers;
+        std::vector<Track> m_tracks;
 
     };
 
diff --git a/include/opendspxconverter/opendspxconverterglobal.h b/include/opendspxconverter/opendspxconverterglobal.h
index 6ec1f86..89b1eae 100644
--- a/include/opendspxconverter/opendspxconverterglobal.h
+++ b/include/opendspxconverter/opendspxconverterglobal.h
@@ -1,16 +1,16 @@
 #ifndef OPENDSPX_CONVERTER_OPENDSPXCONVERTERGLOBAL_H
 #define OPENDSPX_CONVERTER_OPENDSPXCONVERTERGLOBAL_H
 
-#include <QtCore/QtGlobal>
+#include <stdcorelib/stdc_global.h>
 
 #ifndef OPENDSPX_CONVERTER_EXPORT
 #  ifdef OPENDSPX_CONVERTER_STATIC
 #    define OPENDSPX_CONVERTER_EXPORT
 #  else
 #    ifdef OPENDSPX_CONVERTER_LIBRARY
-#      define OPENDSPX_CONVERTER_EXPORT Q_DECL_EXPORT
+#      define OPENDSPX_CONVERTER_EXPORT STDCORELIB_DECL_EXPORT
 #    else
-#      define OPENDSPX_CONVERTER_EXPORT Q_DECL_IMPORT
+#      define OPENDSPX_CONVERTER_EXPORT STDCORELIB_DECL_IMPORT
 #    endif
 #  endif
 #endif
diff --git a/include/opendspxinterpolator/interpolator.h b/include/opendspxinterpolator/interpolator.h
new file mode 100644
index 0000000..20f1620
--- /dev/null
+++ b/include/opendspxinterpolator/interpolator.h
@@ -0,0 +1,111 @@
+#ifndef OPENDSPX_INTERPOLATOR_INTERPOLATOR_H
+#define OPENDSPX_INTERPOLATOR_INTERPOLATOR_H
+
+#include <array>
+#include <cmath>
+
+namespace opendspx {
+
+    template <typename T>
+    class Interpolator {
+    public:
+        static constexpr Interpolator create(T x1, T y1, T x2, T y2, T xref1, T yref1, T xref2, T yref2);
+        static constexpr Interpolator createWithRef1Only(T x1, T y1, T x2, T y2, T xref1, T yref1);
+        static constexpr Interpolator createWithRef2Only(T x1, T y1, T x2, T y2, T xref2, T yref2);
+        static constexpr Interpolator createLinear(T x1, T y1, T x2, T y2);
+
+        constexpr T evaluate(T x) const;
+
+    private:
+        std::array<T, 4> m_coeffs;
+
+        constexpr Interpolator(std::array<T, 4> coeffs) : m_coeffs(coeffs) {
+        }
+    };
+
+    namespace impl {
+        template <typename T>
+        constexpr std::array<T, 4> calculateHermiteCoefficients(T x1, T y1, T d1, T x2, T y2, T d2) {
+            T h = x2 - x1;
+            T f_x1x2 = (y2 - y1) / h;
+
+            T c0 = y1;
+            T c1 = d1;
+            T c2 = (f_x1x2 - d1) / h;
+            T f_x1x2x2 = (d2 - f_x1x2) / h;
+            T c3 = (f_x1x2x2 - c2) / h;
+
+            std::array<T, 4> a;
+
+            a[3] = c3;
+            a[2] = c2 - c3 * (2 * x1 + x2);
+            a[1] = c1 - 2 * x1 * c2 + c3 * (x1 * x1 + 2 * x1 * x2);
+            a[0] = c0 - x1 * c1 + x1 * x1 * c2 - x1 * x1 * x2 * c3;
+
+            return a;
+        }
+
+        template <typename T>
+        constexpr T fb(T xl, T yl, T x0, T y0, T xr, T yr) {
+            const T h_l = x0 - xl;
+            const T h_r = xr - x0;
+
+            const T delta_l = (y0 - yl) / h_l;
+            const T delta_r = (yr - y0) / h_r;
+
+            if (delta_l * delta_r <= 0) {
+                return 0;
+            }
+
+            const T w1 = 2 * h_r + h_l;
+            const T w2 = h_r + 2 * h_l;
+
+            return (w1 + w2) / (w1 / delta_l + w2 / delta_r);
+        }
+
+        template <typename T>
+        constexpr T fbLeftBoundary(T x0, T y0, T x1, T y1) {
+            return (y1 - y0) / (x1 - x0);
+        }
+
+        template <typename T>
+        constexpr T fbRightBoundary(T xn_1, T yn_1, T xn, T yn) {
+            return (yn - yn_1) / (xn - xn_1);
+        }
+
+    }
+
+    template <typename T>
+    constexpr Interpolator<T> Interpolator<T>::create(T x1, T y1, T x2, T y2, T xref1, T yref1, T xref2, T yref2) {
+        T d1 = impl::fb(xref1, yref1, x1, y1, x2, y2);
+        T d2 = impl::fb(x1, y1, x2, y2, xref2, yref2);
+        return Interpolator{impl::calculateHermiteCoefficients(x1, y1, d1, x2, y2, d2)};
+    }
+
+    template <typename T>
+    constexpr Interpolator<T> Interpolator<T>::createWithRef1Only(T x1, T y1, T x2, T y2, T xref1, T yref1) {
+        T d1 = impl::fb(xref1, yref1, x1, y1, x2, y2);
+        T d2 = impl::fbRightBoundary(x1, y1, x2, y2);
+        return Interpolator{impl::calculateHermiteCoefficients(x1, y1, d1, x2, y2, d2)};
+    }
+
+    template <typename T>
+    constexpr Interpolator<T> Interpolator<T>::createWithRef2Only(T x1, T y1, T x2, T y2, T xref2, T yref2) {
+        T d1 = impl::fbLeftBoundary(x1, y1, x2, y2);
+        T d2 = impl::fb(x1, y1, x2, y2, xref2, yref2);
+        return Interpolator{impl::calculateHermiteCoefficients(x1, y1, d1, x2, y2, d2)};
+    }
+
+    template <typename T>
+    constexpr Interpolator<T> Interpolator<T>::createLinear(T x1, T y1, T x2, T y2) {
+        return Interpolator{{(x1 * y2 - x2 * y1) / (x1 - x2), (y1 - y2) / (x1 - x2), T(0), T(0)}};
+    }
+
+    template <typename T>
+    constexpr T Interpolator<T>::evaluate(T x) const {
+        return ((m_coeffs[3] * x + m_coeffs[2]) * x + m_coeffs[1]) * x + m_coeffs[0];
+    }
+
+}
+
+#endif //OPENDSPX_INTERPOLATOR_INTERPOLATOR_H
diff --git a/include/opendspxserializer/jsonconverterv1.h b/include/opendspxserializer/jsonconverterv1.h
index 83a2333..9666407 100644
--- a/include/opendspxserializer/jsonconverterv1.h
+++ b/include/opendspxserializer/jsonconverterv1.h
@@ -1,297 +1,411 @@
 #ifndef OPENDSPX_SERIALIZER_JSONCONVERTERV1_H
 #define OPENDSPX_SERIALIZER_JSONCONVERTERV1_H
 
-#include <QJsonValue>
+#include <nlohmann/json.hpp>
 
+#include <opendspx/model.h>
 #include <opendspxserializer/serializer.h>
-
-namespace QDspx {
-
-    struct AnchorNode;
-    struct AudioClip;
-    using AudioClipRef = QSharedPointer<AudioClip>;
-    struct BusControl;
-    struct Clip;
-    using ClipRef = QSharedPointer<Clip>;
-    struct ClipTime;
-    struct Content;
-    struct ControlPoint;
-    struct Global;
-    class Label;
-    struct Master;
-    struct Model;
-    struct Note;
-    struct Param;
-    struct ParamCurve;
-    using ParamCurveRef = QSharedPointer<ParamCurve>;
-    struct ParamCurveAnchor;
-    using ParamCurveAnchorRef = QSharedPointer<ParamCurveAnchor>;
-    struct ParamCurveFree;
-    using ParamCurveFreeRef = QSharedPointer<ParamCurveFree>;
-    using Params = QMap<QString, Param>;
-    struct Phoneme;
-    struct Phonemes;
-    struct Pronunciation;
-    struct SingingClip;
-    using SingingClipRef = QSharedPointer<SingingClip>;
-    using Sources = QMap<QString, QJsonObject>;
-    struct Tempo;
-    struct TimeSignature;
-    struct Timeline;
-    struct Track;
-    struct TrackControl;
-    struct Vibrato;
-    struct VibratoPoints;
-    using Workspace = QMap<QString, QJsonObject>;
+#include <opendspxserializer/private/declarative_p.h>
+#include <opendspxserializer/private/sourcehelpers_p.h>
+
+namespace opendspx {
+
+    namespace impl {
+        using INTERP_ENUM_DEFS = decl::EnumDef<const char *, AnchorNode::Interpolation,
+            decl::EnumEntry<decl::FixedString("none"), AnchorNode::Interpolation::None>,
+            decl::EnumEntry<decl::FixedString("linear"), AnchorNode::Interpolation::Linear>,
+            decl::EnumEntry<decl::FixedString("hermite"), AnchorNode::Interpolation::Hermite>
+        >;
+
+        using CLIP_AUDIO_TYPE_ENUM_DEFS = decl::EnumDef<const char *, Clip::Type,
+            decl::EnumEntry<decl::FixedString("audio"), Clip::Type::Audio>
+        >;
+
+        using CLIP_SINGING_TYPE_ENUM_DEFS = decl::EnumDef<const char *, Clip::Type,
+            decl::EnumEntry<decl::FixedString("singing"), Clip::Type::Singing>
+        >;
+
+        using SINGER_SINGLE_TYPE_ENUM_DEFS = decl::EnumDef<const char *, Singer::Type,
+            decl::EnumEntry<decl::FixedString("single"), Singer::Type::Single>
+        >;
+
+        using SINGER_MIXED_TYPE_ENUM_DEFS = decl::EnumDef<const char *, Singer::Type,
+            decl::EnumEntry<decl::FixedString("mixed"), Singer::Type::Mixed>
+        >;
+
+        using PARAM_CURVE_ANCHOR_TYPE_ENUM_DEFS = decl::EnumDef<const char *, ParamCurve::Type,
+            decl::EnumEntry<decl::FixedString("anchor"), ParamCurve::Type::Anchor>
+        >;
+
+        using PARAM_CURVE_FREE_TYPE_ENUM_DEFS = decl::EnumDef<const char *, ParamCurve::Type,
+            decl::EnumEntry<decl::FixedString("free"), ParamCurve::Type::Free>
+        >;
+
+        using MODEL_VERSION_ENUM_DEFS = decl::EnumDef<const char *, Model::Version,
+            decl::EnumEntry<decl::FixedString("1.0.0"), Model::Version::V1>
+        >;
+
+        using DENOMINATOR_ENUM_DEFS = decl::EnumDef<int, int,
+            decl::EnumEntry<1, 1>,
+            decl::EnumEntry<2, 2>,
+            decl::EnumEntry<4, 4>,
+            decl::EnumEntry<8, 8>,
+            decl::EnumEntry<16, 16>,
+            decl::EnumEntry<32, 32>,
+            decl::EnumEntry<64, 64>,
+            decl::EnumEntry<128, 128>
+        >;
+
+        template<>
+        struct decl::Mapping<AnchorNode> {
+            using type = Entity<AnchorNode,
+                Property<&AnchorNode::x, "x", RangeConstraintConvert<0>>,
+                Property<&AnchorNode::y, "y">,
+                Property<&AnchorNode::interp, "interp", EnumConstraintConvert<INTERP_ENUM_DEFS>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<AudioClip> {
+            using type = Entity<AudioClip,
+                Property<&AudioClip::control, "control">,
+                Property<&AudioClip::name, "name">,
+                Property<&AudioClip::path, "path">,
+                Property<&AudioClip::time, "time">,
+                Property<&AudioClip::type, "type", EnumConstraintConvert<CLIP_AUDIO_TYPE_ENUM_DEFS>>,
+                Property<&AudioClip::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<BusControl> {
+            using type = Entity<BusControl,
+                Property<&BusControl::gain, "gain">,
+                Property<&BusControl::mute, "mute">,
+                Property<&BusControl::pan, "pan", RangeConstraintConvert<-1, 1>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Clip> {
+            using type = BaseEntity<Clip, &Clip::type, "type",
+                Derive<Clip::Type::Audio, "audio", AudioClip>,
+                Derive<Clip::Type::Singing, "singing", SingingClip>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<ClipTime> {
+            using type = Entity<ClipTime,
+                Property<&ClipTime::clipLen, "clipLen", RangeConstraintConvert<0>>,
+                Property<&ClipTime::clipStart, "clipStart", RangeConstraintConvert<0>>,
+                Property<&ClipTime::length, "length", RangeConstraintConvert<0>>,
+                Property<&ClipTime::pos, "pos", RangeConstraintConvert<0>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Content> {
+            using type = Entity<Content,
+                Property<&Content::global, "global">,
+                Property<&Content::master, "master">,
+                Property<&Content::timeline, "timeline">,
+                Property<&Content::tracks, "tracks">,
+                Property<&Content::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<ControlPoint> {
+            using type = Entity<ControlPoint,
+                Property<&ControlPoint::x, "x">,
+                Property<&ControlPoint::y, "y">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<DynamicMixingAnchor> {
+            using type = Entity<DynamicMixingAnchor,
+                Property<&DynamicMixingAnchor::pos, "pos", RangeConstraintConvert<0>>,
+                Property<&DynamicMixingAnchor::ratio, "ratio", SourceMixingRatioConvert>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Global> {
+            using type = Entity<Global,
+                Property<&Global::author, "author">,
+                Property<&Global::name, "name">,
+                Property<&Global::centShift, "centShift", RangeConstraintConvert<-50, 50>>,
+                Property<&Global::editorId, "editorId">,
+                Property<&Global::editorName, "editorName">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Label> {
+            using type = Entity<Label,
+                Property<&Label::pos, "pos", RangeConstraintConvert<0>>,
+                Property<&Label::text, "text">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Master> {
+            using type = Entity<Master,
+                Property<&Master::control, "control">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Model> {
+            using type = Entity<Model,
+                Property<&Model::version, "version", EnumConstraintConvert<MODEL_VERSION_ENUM_DEFS>>,
+                Property<&Model::content, "content">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Note> {
+            using type = Entity<Note,
+                Property<&Note::pos, "pos", RangeConstraintConvert<0>>,
+                Property<&Note::length, "length", RangeConstraintConvert<0>>,
+                Property<&Note::keyNum, "keyNum", RangeConstraintConvert<0, 127>>,
+                Property<&Note::centShift, "centShift", RangeConstraintConvert<-50, 50>>,
+                Property<&Note::language, "language">,
+                Property<&Note::lyric, "lyric">,
+                Property<&Note::pronunciation, "pronunciation">,
+                Property<&Note::phonemes, "phonemes">,
+                Property<&Note::vibrato, "vibrato">,
+                Property<&Note::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Param> {
+            using type = Entity<Param,
+                Property<&Param::original, "original">,
+                Property<&Param::transform, "transform">,
+                Property<&Param::edited, "edited">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Params> {
+            using type = MapEntity<Params>;
+        };
+
+        template<>
+        struct decl::Mapping<ParamCurve> {
+            using type = BaseEntity<ParamCurve, &ParamCurve::type, "type",
+                Derive<ParamCurve::Type::Anchor, "anchor", ParamCurveAnchor>,
+                Derive<ParamCurve::Type::Free, "free", ParamCurveFree>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<ParamCurveAnchor> {
+            using type = Entity<ParamCurveAnchor,
+                Property<&ParamCurveAnchor::start, "start">,
+                Property<&ParamCurveAnchor::nodes, "nodes">,
+                Property<&ParamCurveAnchor::type, "type", EnumConstraintConvert<PARAM_CURVE_ANCHOR_TYPE_ENUM_DEFS>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<ParamCurveFree> {
+            using type = Entity<ParamCurveFree,
+                Property<&ParamCurveFree::start, "start">,
+                Property<&ParamCurveFree::step, "step", RangeConstraintConvert<5, 5>>,
+                Property<&ParamCurveFree::values, "values", ArrayRangeConstraintConvert<>>,
+                Property<&ParamCurveFree::type, "type", EnumConstraintConvert<PARAM_CURVE_FREE_TYPE_ENUM_DEFS>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Phoneme> {
+            using type = Entity<Phoneme,
+                Property<&Phoneme::language, "language">,
+                Property<&Phoneme::token, "token">,
+                Property<&Phoneme::start, "start">,
+                Property<&Phoneme::onset, "onset">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Phonemes> {
+            using type = Entity<Phonemes,
+                Property<&Phonemes::original, "original">,
+                Property<&Phonemes::edited, "edited">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Pronunciation> {
+            using type = Entity<Pronunciation,
+                Property<&Pronunciation::original, "original">,
+                Property<&Pronunciation::edited, "edited">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Singer> {
+            using type = BaseEntity<Singer, &Singer::type, "type",
+                Derive<Singer::Type::Single, "single", SingleSinger>,
+                Derive<Singer::Type::Mixed, "mixed", MixedSinger>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<SingleSinger> {
+            using type = Entity<SingleSinger,
+                Property<&SingleSinger::extra, "extra">,
+                Property<&SingleSinger::id, "id">,
+                Property<&SingleSinger::type, "type", EnumConstraintConvert<SINGER_SINGLE_TYPE_ENUM_DEFS>>,
+                Property<&SingleSinger::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<MixedSinger> {
+            using type = Entity<MixedSinger,
+                Property<&MixedSinger::extra, "extra">,
+                Property<&MixedSinger::ratio, "ratio", SourceMixingRatioConvert>,
+                Property<&MixedSinger::singers, "singers">,
+                Property<&MixedSinger::type, "type", EnumConstraintConvert<SINGER_MIXED_TYPE_ENUM_DEFS>>,
+                Property<&MixedSinger::workspace, "workspace">,
+                EntityWithRatioPostCheck
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<SingingClip> {
+            using type = Entity<SingingClip,
+                Property<&SingingClip::control, "control">,
+                Property<&SingingClip::name, "name">,
+                Property<&SingingClip::notes, "notes">,
+                Property<&SingingClip::params, "params">,
+                Property<&SingingClip::sources, "sources">,
+                Property<&SingingClip::time, "time">,
+                Property<&SingingClip::type, "type", EnumConstraintConvert<CLIP_SINGING_TYPE_ENUM_DEFS>>,
+                Property<&SingingClip::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Sources> {
+            using type = Entity<Sources,
+                Property<&Sources::category, "category">,
+                Property<&Sources::mix, "mix">,
+                Property<&Sources::singers, "singers">,
+                EntityWithRatioPostCheck
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<SourceMixingRatio> {
+            struct type {
+                static bool fromJson(const nlohmann::json &object, SourceMixingRatio &entity, const JsonSerializationContext &context) {
+                    return ArrayRangeConstraintConvert<0, 1>::template getFromJsonFunc<SourceMixingRatio>()(object, entity, context);
+                }
+                static bool toJson(nlohmann::json &object, const SourceMixingRatio &entity, const JsonSerializationContext &context) {
+                    return ArrayRangeConstraintConvert<0, 1>::template getToJsonFunc<SourceMixingRatio>()(object, entity, context);
+                }
+            };
+        };
+
+        template<>
+        struct decl::Mapping<Tempo> {
+            using type = Entity<Tempo,
+                Property<&Tempo::pos, "pos", RangeConstraintConvert<0>>,
+                Property<&Tempo::value, "value", RangeConstraintConvert<10, 1000>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<TimeSignature> {
+            using type = Entity<TimeSignature,
+                Property<&TimeSignature::index, "index", RangeConstraintConvert<0>>,
+                Property<&TimeSignature::numerator, "numerator", RangeConstraintConvert<1>>,
+                Property<&TimeSignature::denominator, "denominator", EnumConstraintConvert<DENOMINATOR_ENUM_DEFS>>
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Timeline> {
+            using type = Entity<Timeline,
+                Property<&Timeline::labels, "labels">,
+                Property<&Timeline::tempos, "tempos">,
+                Property<&Timeline::timeSignatures, "timeSignatures">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Track> {
+            using type = Entity<Track,
+                Property<&Track::name, "name">,
+                Property<&Track::control, "control">,
+                Property<&Track::clips, "clips">,
+                Property<&Track::workspace, "workspace">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<TrackControl> {
+            using type = Entity<TrackControl,
+                Property<&TrackControl::gain, "gain">,
+                Property<&TrackControl::pan, "pan", RangeConstraintConvert<-1, 1>>,
+                Property<&TrackControl::mute, "mute">,
+                Property<&TrackControl::solo, "solo">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Vibrato> {
+            using type = Entity<Vibrato,
+                Property<&Vibrato::start, "start", RangeConstraintConvert<0, 1>>,
+                Property<&Vibrato::end, "end", RangeConstraintConvert<0, 1>>,
+                Property<&Vibrato::amp, "amp", RangeConstraintConvert<0>>,
+                Property<&Vibrato::freq, "freq", RangeConstraintConvert<0>>,
+                Property<&Vibrato::phase, "phase", RangeConstraintConvert<0, 1>>,
+                Property<&Vibrato::offset, "offset">,
+                Property<&Vibrato::points, "points">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<VibratoPoints> {
+            using type = Entity<VibratoPoints,
+                Property<&VibratoPoints::amp, "amp">,
+                Property<&VibratoPoints::freq, "freq">
+            >;
+        };
+
+        template<>
+        struct decl::Mapping<Workspace> {
+            using type = MapEntity<Workspace>;
+        };
+
+    }
 
     class OPENDSPX_SERIALIZER_EXPORT JsonConverterV1 {
     public:
         template <typename T>
-        static QJsonValue toJson(const T &entity, SerializationErrorList &errors, Serializer::Option options = {Serializer::FailFast | Serializer::CheckError}, const QString &path = {"$"}) {
-            static_assert(sizeof(T) == 0, "JsonConverterV1::toJson: unsupported type");
+        static nlohmann::json toJson(const T &entity, SerializationErrorList &errors, Serializer::Option options = {Serializer::FailFast | Serializer::CheckError}, const std::string &path = {"$"}) {
+            nlohmann::json json;
+            impl::decl::TrivialOrMappingConvert::getToJsonFunc<T>()(json, entity, impl::JsonSerializationContext{errors, options, path});
+            return json;
         }
 
         template <typename T>
-        static T fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options = {Serializer::FailFast | Serializer::CheckError}, const QString &path = {"$"}) {
-            static_assert(sizeof(T) == 0, "JsonConverterV1::fromJson: unsupported type");
+        static T fromJson(const nlohmann::json &json, SerializationErrorList &errors, Serializer::Option options = {Serializer::FailFast | Serializer::CheckError}, const std::string &path = {"$"}) {
+            T entity;
+            impl::decl::TrivialOrMappingConvert::getFromJsonFunc<T>()(json, entity, impl::JsonSerializationContext{errors, options, path});
+            return entity;
         }
 
     };
 
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const AnchorNode &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT AnchorNode JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const AudioClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT AudioClipRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const BusControl &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT BusControl JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ClipRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ClipTime &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ClipTime JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Content &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Content JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ControlPoint &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ControlPoint JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Global &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Global JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Label &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Label JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<Label> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<Label> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Master &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Master JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Model &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Model JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Note &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Note JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<Note> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<Note> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Param &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Param JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ParamCurveRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ParamCurveRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ParamCurveAnchorRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ParamCurveAnchorRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const ParamCurveFreeRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT ParamCurveFreeRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<ParamCurveRef> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<ParamCurveRef> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Params &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Params JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Phoneme &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Phoneme JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<Phoneme> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<Phoneme> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Phonemes &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Phonemes JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Pronunciation &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Pronunciation JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const SingingClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT SingingClipRef JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Sources &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Sources JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Tempo &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Tempo JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<Tempo> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<Tempo> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const TimeSignature &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT TimeSignature JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<TimeSignature> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<TimeSignature> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Timeline &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Timeline JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Track &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Track JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<Track> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<Track> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const TrackControl &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT TrackControl JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const Vibrato &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT Vibrato JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const VibratoPoints &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT VibratoPoints JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<ControlPoint> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<ControlPoint> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<AnchorNode> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<AnchorNode> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QJsonValue JsonConverterV1::toJson(const QList<ClipRef> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
-    template <>
-    OPENDSPX_SERIALIZER_EXPORT QList<ClipRef> JsonConverterV1::fromJson(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path);
-
 }
 
 #endif //OPENDSPX_SERIALIZER_JSONCONVERTERV1_H
diff --git a/include/opendspxserializer/opendspxserializerglobal.h b/include/opendspxserializer/opendspxserializerglobal.h
index d9ed7d0..2b4bfab 100644
--- a/include/opendspxserializer/opendspxserializerglobal.h
+++ b/include/opendspxserializer/opendspxserializerglobal.h
@@ -1,16 +1,16 @@
 #ifndef OPENDSPX_SERIALIZER_OPENDSPXSERIALIZERGLOBAL_H
 #define OPENDSPX_SERIALIZER_OPENDSPXSERIALIZERGLOBAL_H
 
-#include <QtCore/QtGlobal>
+#include <stdcorelib/stdc_global.h>
 
 #ifndef OPENDSPX_SERIALIZER_EXPORT
 #  ifdef OPENDSPX_SERIALIZER_STATIC
 #    define OPENDSPX_SERIALIZER_EXPORT
 #  else
 #    ifdef OPENDSPX_SERIALIZER_LIBRARY
-#      define OPENDSPX_SERIALIZER_EXPORT Q_DECL_EXPORT
+#      define OPENDSPX_SERIALIZER_EXPORT STDCORELIB_DECL_EXPORT
 #    else
-#      define OPENDSPX_SERIALIZER_EXPORT Q_DECL_IMPORT
+#      define OPENDSPX_SERIALIZER_EXPORT STDCORELIB_DECL_IMPORT
 #    endif
 #  endif
 #endif
diff --git a/include/opendspxserializer/private/declarative_p.h b/include/opendspxserializer/private/declarative_p.h
new file mode 100644
index 0000000..321a670
--- /dev/null
+++ b/include/opendspxserializer/private/declarative_p.h
@@ -0,0 +1,403 @@
+#ifndef OPENDSPX_SERIALIZATION_DECLARATIVE_P_H
+#define OPENDSPX_SERIALIZATION_DECLARATIVE_P_H
+
+#include <optional>
+
+#include <opendspxserializer/private/helpers_p.h>
+
+namespace opendspx::impl::decl {
+
+    template <typename T>
+    struct member_pointer_traits;
+
+    template <typename M, typename C>
+    struct member_pointer_traits<M C::*> {
+        using member_type = M;
+        using class_type = C;
+    };
+
+    template <typename M, typename C>
+    struct member_pointer_traits<M C::* const> {
+        using member_type = M;
+        using class_type = C;
+    };
+
+    template <typename T>
+    struct is_vector : std::false_type {};
+
+    template <typename T, typename Alloc>
+    struct is_vector<std::vector<T, Alloc>> : std::true_type {};
+
+    template <typename T>
+    struct is_shared_ptr : std::false_type {};
+
+    template <typename T>
+    struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+    template <typename T>
+    struct is_optional : std::false_type {};
+
+    template <typename T>
+    struct is_optional<std::optional<T>> : std::true_type {};
+
+    template <typename E>
+    struct Mapping;
+
+    template <typename T>
+    concept IsMapped = requires {
+        typename Mapping<T>::type;
+    };
+
+    struct TrivialOrMappingConvert {
+        template <typename T_>
+        static constexpr auto getFromJsonFunc() {
+            using T = std::remove_cvref_t<T_>;
+            if constexpr (std::is_same_v<T, nlohmann::json>) {
+                return [](const nlohmann::json &object, T &entity, const JsonSerializationContext &) {
+                    entity = object;
+                    return true;
+                };
+            } else if constexpr (std::is_same_v<T, int>) {
+                return fromJsonIntHelperWithConstraint<>;
+            } else if constexpr (std::is_same_v<T, double>) {
+                return fromJsonDoubleHelperWithConstraint<>;
+            } else if constexpr (std::is_same_v<T, bool>) {
+                return fromJsonBoolHelper;
+            } else if constexpr (std::is_same_v<T, std::string>) {
+                return fromJsonStringHelper;
+            } else if constexpr (IsMapped<T>) {
+                return [](const nlohmann::json &object, T &entity, const JsonSerializationContext &context) {
+                    return Mapping<T>::type::fromJson(object, entity, context);
+                };
+            } else if constexpr (is_vector<T>::value) {
+                using E = typename T::value_type;
+                return fromJsonArrayHelper<E, getFromJsonFunc<E>()>;
+            } else if constexpr (is_shared_ptr<T>::value) {
+                using E = typename T::element_type;
+                static_assert(IsMapped<E>);
+                return [](const nlohmann::json &object, T &entity, const JsonSerializationContext &context) {
+                    return Mapping<E>::type::fromJson(object, entity, context);
+                };
+            } else if constexpr (is_optional<T>::value) {
+                using E = typename T::value_type;
+                return [](const nlohmann::json &object, T &entity, const JsonSerializationContext &context) {
+                    if (object.is_null()) {
+                        entity.reset();
+                        return true;
+                    }
+                    E value{};
+                    if (!TrivialOrMappingConvert::getFromJsonFunc<E>()(object, value, context)) {
+                        return false;
+                    }
+                    entity = std::move(value);
+                    return true;
+                };
+            } else {
+                static_assert(sizeof(T) == 0, "Unsupported type");
+            }
+        }
+
+        template<typename T_>
+        static constexpr auto getToJsonFunc() {
+            using T = std::remove_cvref_t<T_>;
+            if constexpr (std::is_same_v<T, nlohmann::json>) {
+                return [](nlohmann::json &object, const T &entity, const JsonSerializationContext &) {
+                    object = entity;
+                    return true;
+                };
+            } else if constexpr (std::is_same_v<T, int>) {
+                return toJsonTrivial<T>;
+            } else if constexpr (std::is_same_v<T, double>) {
+                return toJsonTrivial<T>;
+            } else if constexpr (std::is_same_v<T, bool>) {
+                return toJsonTrivial<T>;
+            } else if constexpr (std::is_same_v<T, std::string>) {
+                return toJsonTrivial<T>;
+            } else if constexpr (IsMapped<T>) {
+                return [](nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+                    return Mapping<T>::type::toJson(object, entity, context);
+                };
+            } else if constexpr (is_vector<T>::value) {
+                using E = typename T::value_type;
+                return toJsonArrayHelper<E, getToJsonFunc<E>()>;
+            } else if constexpr (is_shared_ptr<T>::value) {
+                using E = typename T::element_type;
+                static_assert(IsMapped<E>);
+                return [](nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+                    return Mapping<E>::type::toJson(object, entity, context);
+                };
+            } else if constexpr (is_optional<T>::value) {
+                using E = typename T::value_type;
+                return [](nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+                    if (!entity.has_value()) {
+                        object = nullptr;
+                        return true;
+                    }
+                    return TrivialOrMappingConvert::getToJsonFunc<E>()(object, *entity, context);
+                };
+            } else {
+                static_assert(sizeof(T) == 0, "Unsupported type");
+            }
+        }
+    };
+
+    template <auto minValue = std::nullopt, auto maxValue = std::nullopt>
+    struct RangeConstraintConvert {
+        template <typename T>
+        static constexpr auto getFromJsonFunc() {
+            if constexpr (std::is_same_v<T, int>) {
+                return fromJsonIntHelperWithConstraint<minValue, maxValue>;
+            } else if constexpr (std::is_same_v<T, double>) {
+                return fromJsonDoubleHelperWithConstraint<minValue, maxValue>;
+            } else {
+                static_assert(sizeof(T) == 0, "Unsupported type");
+            }
+        }
+
+        template <typename T>
+        static constexpr auto getToJsonFunc() {
+            return [] (nlohmann::json &json, const T &value, const JsonSerializationContext &context) {
+                return toJsonNumberHelperWithConstraint<T, minValue, maxValue>(json, value, context);
+            };
+        }
+    };
+
+    template <auto minValue = std::nullopt, auto maxValue = std::nullopt>
+    struct ArrayRangeConstraintConvert {
+        template <typename T_>
+        static constexpr auto getFromJsonFunc() {
+            using T = std::remove_cvref_t<T_>;
+            if constexpr (std::is_same_v<typename T::value_type, int>) {
+                return fromJsonArrayHelper<int, fromJsonIntHelperWithConstraint<minValue, maxValue>>;
+            } else if constexpr (std::is_same_v<typename T::value_type, double>) {
+                return fromJsonArrayHelper<double, fromJsonDoubleHelperWithConstraint<minValue, maxValue>>;
+            } else {
+                static_assert(sizeof(T) == 0, "Unsupported type");
+            }
+        }
+
+        template <typename T_>
+        static constexpr auto getToJsonFunc() {
+            return toJsonArrayHelper<typename T_::value_type, toJsonNumberHelperWithConstraint<typename T_::value_type, minValue, maxValue>>;
+        }
+    };
+
+    template <auto enumKey_, auto enumValue_>
+    struct EnumEntry {
+        static constexpr auto enumKey = enumKey_;
+        static constexpr auto enumValue = enumValue_;
+    };
+
+    template <typename K, typename T, typename... EnumEntries>
+    struct EnumDef {
+        static constexpr std::array<std::pair<K, T>, sizeof...(EnumEntries)> toArray() {
+            return {std::pair<K, T>{K(EnumEntries::enumKey), T(EnumEntries::enumValue)}...};
+        }
+    };
+
+    template <typename E>
+    struct EnumConstraintConvert {
+        template <typename T>
+        static constexpr auto getFromJsonFunc() {
+            return fromJsonEnumHelper(E::toArray());
+        }
+
+        template <typename T>
+        static constexpr auto getToJsonFunc() {
+            return toJsonEnumHelper(E::toArray());
+        }
+    };
+
+    template<size_t N>
+    struct FixedString {
+        char str[N];
+        constexpr FixedString(const char (&str_)[N]) {
+            std::copy_n(str_, N, str);
+        }
+        constexpr operator const char*() const {
+            return str;
+        }
+    };
+
+    template <auto propertyPtr_, FixedString propertyName_, typename Convert = TrivialOrMappingConvert>
+    struct Property {
+        static constexpr auto propertyPtr = propertyPtr_;
+        static constexpr auto propertyName = propertyName_.str;
+        using EntityType = typename member_pointer_traits<decltype(propertyPtr)>::class_type;
+        using PropertyType = typename member_pointer_traits<decltype(propertyPtr)>::member_type;
+
+        static bool fromJson(const nlohmann::json &object, EntityType &entity, const JsonSerializationContext &context) {
+            if (!object.contains(propertyName)) {
+                return false;
+            }
+            const auto &v = object.at(propertyName);
+            bool ok = Convert::template getFromJsonFunc<PropertyType>()(v, entity.*propertyPtr, {context.errors, context.options, context.path + "." + propertyName});
+            if (!ok && (context.options & Serializer::FailFast)) {
+                return false;
+            }
+            return ok;
+        }
+        static bool toJson(nlohmann::json &object, const EntityType &entity, const JsonSerializationContext &context) {
+            const auto &v = entity.*propertyPtr;
+            bool ok = Convert::template getToJsonFunc<PropertyType>()(object[propertyName], v, {context.errors, context.options, context.path + "." + propertyName});
+            if (!ok && (context.options & Serializer::FailFast)) {
+                return false;
+            }
+            return ok;
+        }
+    };
+
+    template <typename T>
+    concept HasPropertyNameMember = requires {
+        T::propertyName;
+    };
+
+    template <typename... PropertyDecls>
+    consteval auto makePropertyNameArray() {
+        constexpr size_t count = (size_t(0) + ... + (HasPropertyNameMember<PropertyDecls> ? 1 : 0));
+        std::array<const char *, count> names{};
+        size_t index = 0;
+        (([&] {
+            if constexpr (HasPropertyNameMember<PropertyDecls>) {
+                names[index++] = PropertyDecls::propertyName;
+            }
+        }()), ...);
+        return names;
+    }
+
+    template <typename T, typename... PropertyDecls>
+    struct Entity {
+        static bool fromJson(const nlohmann::json &object_, T &entity, const JsonSerializationContext &context) {
+            nlohmann::json object;
+            bool ok = fromJsonObjectHelperWithPropertyCheck(makePropertyNameArray<PropertyDecls...>())(object_, object, context);
+            if (!ok && (context.options & Serializer::FailFast)) {
+                return false;
+            }
+            if (context.options & Serializer::FailFast)
+                return (PropertyDecls::fromJson(object, entity, context) && ...);
+            return (PropertyDecls::fromJson(object, entity, context), ...);
+        }
+        static bool fromJson(const nlohmann::json &object, std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            if (!entity) {
+                entity = std::make_shared<T>();
+            }
+            return fromJson(object, *entity, context);
+        }
+        static bool toJson(nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+            object = nlohmann::json::object();
+            if (context.options & Serializer::FailFast)
+                return (PropertyDecls::toJson(object, entity, context) && ...);
+            return (PropertyDecls::toJson(object, entity, context), ...);
+        }
+        static bool toJson(nlohmann::json &object, const std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            return toJson(object, *entity, context);
+        }
+    };
+
+    template <auto objectTypeEnum_, FixedString objectTypeName_, typename T>
+    struct Derive {
+        using EntityType = T;
+        static constexpr auto objectTypeName = objectTypeName_.str;
+        static constexpr auto objectTypeEnum = objectTypeEnum_;
+    };
+
+    template <typename T, auto objectTypePropertyPtr, FixedString objectTypePropertyName_, typename... DeriveDecls>
+    struct BaseEntity {
+        static constexpr auto objectTypePropertyName = objectTypePropertyName_.str;
+        static bool fromJson(const nlohmann::json &, T &, const JsonSerializationContext &) {
+            static_assert(sizeof(T) == 0, "BaseEntity::fromJson with T & not supported");
+        }
+        static bool fromJson(const nlohmann::json &object_, std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            nlohmann::json object;
+            bool ok = fromJsonObjectHelper(object_, object, context);
+            if (!ok) {
+                // Ignore fail-fast, because even if fail-fast is disabled, nothing can be done
+                return false;
+            }
+            if (!object.contains(objectTypePropertyName)) {
+                if (context.options & Serializer::CheckError) {
+                    context.errors.addError<MissingPropertyError>(context.path, std::vector<std::string>{objectTypePropertyName});
+                    return false;
+                } else {
+                    // Cannot determine object type, so here just do nothing and return
+                    return true;
+                }
+            }
+            auto objectTypeName = object[objectTypePropertyName].template get<std::string>();
+            bool fwdRet = false;
+            bool found = ((DeriveDecls::objectTypeName == objectTypeName ? ([&] {
+                typename DeriveDecls::EntityType e;
+                fwdRet = Mapping<typename DeriveDecls::EntityType>::type::fromJson(object, e, context);
+                entity = std::make_shared<typename DeriveDecls::EntityType>(std::move(e));
+            }(), true) : false) || ...);
+            if (!found) {
+                if (context.options & Serializer::CheckError) {
+                    context.errors.addError<InvalidObjectTypeError>(context.path, objectTypeName, std::vector<std::string>{DeriveDecls::objectTypeName...});
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+            return fwdRet;
+        }
+        static bool toJson(nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+            auto objectTypeEnum = entity.*objectTypePropertyPtr;
+            bool fwdRet = false;
+            bool found = ((DeriveDecls::objectTypeEnum == objectTypeEnum ? ([&] {
+                fwdRet = Mapping<typename DeriveDecls::EntityType>::type::toJson(object, static_cast<const typename DeriveDecls::EntityType &>(entity), context);
+            }(), true) : false) || ...);
+            if (!found) {
+                assert(false && "Unknown object type enum");
+            }
+            return fwdRet;
+        }
+        static bool toJson(nlohmann::json &object, const std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            return toJson(object, *entity, context);
+        }
+    };
+
+    template <typename T>
+    struct MapEntity {
+        static bool fromJson(const nlohmann::json &object_, T &entity, const JsonSerializationContext &context) {
+            nlohmann::json object;
+            bool ok = fromJsonObjectHelper(object_, object, context);
+            if (!ok) {
+                // Ignore fail-fast, because even if fail-fast is disabled, nothing can be done
+                return false;
+            }
+            for (auto it = object.begin(); it != object.end(); ++it) {
+                typename T::mapped_type contentEntity;
+                if (!TrivialOrMappingConvert::getFromJsonFunc<typename T::mapped_type>()(it.value(), contentEntity, context)) {
+                    if (context.options & Serializer::FailFast)
+                        return false;
+                }
+                entity[it.key()] = contentEntity;
+            }
+            return true;
+        }
+        static bool fromJson(const nlohmann::json &object, std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            if (!entity) {
+                entity = std::make_shared<T>();
+            }
+            return fromJson(object, *entity, context);
+        }
+        static bool toJson(nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+            object = nlohmann::json::object();
+            for (const auto &[key, value] : entity) {
+                nlohmann::json contentJson;
+                if (!TrivialOrMappingConvert::getToJsonFunc<decltype(value)>()(contentJson, value, context)) {
+                    if (context.options & Serializer::FailFast)
+                        return false;
+                }
+                object[key] = contentJson;
+            }
+            return true;
+        }
+        static bool toJson(nlohmann::json &object, const std::shared_ptr<T> &entity, const JsonSerializationContext &context) {
+            return toJson(object, *entity, context);
+        }
+    };
+
+}
+
+#endif //OPENDSPX_SERIALIZATION_DECLARATIVE_P_H
\ No newline at end of file
diff --git a/include/opendspxserializer/private/helpers_p.h b/include/opendspxserializer/private/helpers_p.h
new file mode 100644
index 0000000..5589cfc
--- /dev/null
+++ b/include/opendspxserializer/private/helpers_p.h
@@ -0,0 +1,362 @@
+#ifndef OPENDSPX_SERIALIZATION_HELPERS_P_H
+#define OPENDSPX_SERIALIZATION_HELPERS_P_H
+
+#include <nlohmann/json.hpp>
+
+#include <opendspxserializer/serializer.h>
+#include <opendspxserializer/serializationerror.h>
+
+namespace opendspx::impl {
+
+    struct JsonSerializationContext {
+        SerializationErrorList &errors;
+        Serializer::Option options;
+        std::string path;
+    };
+
+    template <typename T>
+    bool toJsonTrivial(nlohmann::json &json, const T &value, const JsonSerializationContext &) {
+        json = value;
+        return true;
+    }
+
+    template <typename T, auto minimum_ = std::nullopt, auto maximum_ = std::nullopt>
+    bool toJsonNumberHelperWithConstraint(nlohmann::json &json, const T &value, const JsonSerializationContext &context) {
+        const std::optional<T> minimum = minimum_;
+        const std::optional<T> maximum = maximum_;
+        json = 0;
+        if (!(context.options & Serializer::CheckError)) {
+            json = value;
+            return true;
+        }
+        bool ok = true;
+        if (minimum.has_value() && maximum.has_value()) {
+            if (value < minimum || value > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, value, minimum.value(), maximum.value());
+                ok = false;
+            }
+        } else if (minimum.has_value()) {
+            if (value < minimum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, value, minimum.value(), std::any());
+                ok = false;
+            }
+        } else if (maximum.has_value()) {
+            if (value > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, value, std::any(), maximum.value());
+                ok = false;
+            }
+        }
+        json = value;
+        return ok;
+    }
+
+    template <typename K, typename T, size_t N>
+    struct toJsonEnumHelper {
+        explicit toJsonEnumHelper(const std::array<std::pair<K, T>, N> &enumValues) : enumValues(enumValues) {
+        }
+
+        bool operator()(nlohmann::json &json, const T &value, const JsonSerializationContext &context) const {
+            auto it = std::ranges::find_if(enumValues, [value](const auto &pair) {
+                return pair.second == value;
+            });
+            if (it == enumValues.end()) {
+                json = {};
+                if (!(context.options & Serializer::CheckError)) {
+                    return true;
+                }
+                std::vector<std::any> a;
+                for (auto &pair : enumValues) {
+                    a.push_back(pair.second);
+                }
+                context.errors.addError<EnumConstraintViolationError>(context.path, value, std::move(a));
+                return false;
+            }
+            json = it->first;
+            return true;
+        }
+
+        std::array<std::pair<K, T>, N> enumValues;
+    };
+
+    template <typename T, auto toJson = toJsonTrivial<T>>
+    bool toJsonArrayHelper(nlohmann::json &json, const std::vector<T> &entity, const JsonSerializationContext &context) {
+        json = nlohmann::json::array();
+        bool ok = true;
+        for (auto it = entity.begin(); it != entity.end(); ++it) {
+            auto index = std::distance(entity.begin(), it);
+            nlohmann::json item;
+            ok = toJson(item, *it, JsonSerializationContext{context.errors, context.options, context.path + "[" + std::to_string(index) + "]"}) && ok;
+            if ((context.options & Serializer::FailFast) && !ok) {
+                return false;
+            }
+            json.push_back(std::move(item));
+        }
+        if (!(context.options & Serializer::CheckError))
+            return true;
+        return ok;
+    }
+
+}
+
+namespace opendspx::impl {
+
+    inline bool isInteger(double v) {
+        return std::isfinite(v) && std::trunc(v) == v && v >= std::numeric_limits<int>::min() && v <= std::numeric_limits<int>::max();
+    }
+
+    inline InvalidDataTypeError::DataType getDataType(const nlohmann::json &value) {
+        switch (value.type()) {
+            case nlohmann::json::value_t::boolean:
+                return InvalidDataTypeError::Bool;
+            case nlohmann::json::value_t::number_float:
+            case nlohmann::json::value_t::number_integer:
+            case nlohmann::json::value_t::number_unsigned:
+                return isInteger(value.get<double>()) ? InvalidDataTypeError::Integer : InvalidDataTypeError::Double;
+            case nlohmann::json::value_t::string:
+                return InvalidDataTypeError::String;
+            case nlohmann::json::value_t::array:
+                return InvalidDataTypeError::Array;
+            case nlohmann::json::value_t::object:
+                return InvalidDataTypeError::Object;
+            default:
+                return InvalidDataTypeError::Null;
+        }
+    }
+
+    inline bool fromJsonStringHelper(const nlohmann::json &value, std::string &out, const JsonSerializationContext &context) {
+        if (!(context.options & Serializer::CheckError)) {
+            out = value.is_string() ? value.get<std::string>() : std::string{};
+            return true;
+        }
+        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::String) {
+            context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::String});
+            out = {};
+            return false;
+        }
+        out = value.get<std::string>();
+        return true;
+    }
+
+    template <auto minimum_ = std::nullopt, auto maximum_ = std::nullopt>
+    bool fromJsonDoubleHelperWithConstraint(const nlohmann::json &value, double &out, const JsonSerializationContext &context) {
+        const std::optional<double> minimum = minimum_;
+        const std::optional<double> maximum = maximum_;
+        if (!(context.options & Serializer::CheckError)) {
+            out = value.is_number() ? value.get<double>() : 0;
+            return true;
+        }
+        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Double && actualType != InvalidDataTypeError::Integer) {
+            context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Double, InvalidDataTypeError::Integer});
+            out = {};
+            return false;
+        }
+        auto v = value.get<double>();
+        bool ok = true;
+        if (minimum.has_value() && maximum.has_value()) {
+            if (v < minimum || v > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, minimum.value(), maximum.value());
+                ok = false;
+            }
+        } else if (minimum.has_value()) {
+            if (v < minimum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, minimum.value(), std::any());
+                ok = false;
+            }
+        } else if (maximum.has_value()) {
+            if (v > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, std::any(), maximum.value());
+                ok = false;
+            }
+        }
+        out = v;
+        return ok;
+    }
+
+    template <auto minimum_ = std::nullopt, auto maximum_ = std::nullopt>
+    bool fromJsonIntHelperWithConstraint(const nlohmann::json &value, int &out, const JsonSerializationContext &context) {
+        const std::optional<int> minimum = minimum_;
+        const std::optional<int> maximum = maximum_;
+        if (!(context.options & Serializer::CheckError)) {
+            out = value.is_number() ? value.get<int>() : 0;
+            return true;
+        }
+        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Integer) {
+            context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Integer});
+            out = {};
+            return false;
+        }
+        auto v = value.get<int>();
+        bool ok = true;
+        if (minimum.has_value() && maximum.has_value()) {
+            if (v < minimum || v > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, minimum.value(), maximum.value());
+                ok = false;
+            }
+        } else if (minimum.has_value()) {
+            if (v < minimum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, minimum.value(), std::any());
+                ok = false;
+            }
+        } else if (maximum.has_value()) {
+            if (v > maximum) {
+                context.errors.addError<RangeConstraintViolationError>(context.path, v, std::any(), maximum.value());
+                ok = false;
+            }
+        }
+        out = v;
+        return ok;
+    }
+
+    inline bool fromJsonBoolHelper(const nlohmann::json &value, bool &out, const JsonSerializationContext &context) {
+        if (!(context.options & Serializer::CheckError)) {
+            out = value.is_boolean() ? value.get<bool>() : false;
+            return true;
+        }
+        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Bool) {
+            context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Bool});
+            out = false;
+            return false;
+        }
+        out = value.get<bool>();
+        return true;
+    }
+
+    template <typename K, typename T, size_t N>
+    struct fromJsonEnumHelper {
+        static_assert(std::is_same_v<K, const char *> || std::is_same_v<K, int>);
+        using EnumType = std::conditional_t<std::is_same_v<K, const char *>, std::string, int>;
+
+        explicit fromJsonEnumHelper(const std::array<std::pair<K, T>, N> &enumValues) : enumValues(enumValues) {
+        }
+
+        static constexpr InvalidDataTypeError::DataType Flag = std::is_same_v<K, const char *> ? InvalidDataTypeError::String : InvalidDataTypeError::Integer;
+
+        bool operator()(const nlohmann::json &value, T &out, const JsonSerializationContext &context) const {
+            if (!(context.options & Serializer::CheckError)) {
+                if (auto actualType = getDataType(value); actualType != Flag) {
+                    out = {};
+                    return true;
+                }
+                auto s = value.get<EnumType>();
+                auto it = std::ranges::find_if(enumValues, [s](const auto &pair) {
+                    return pair.first == s;
+                });
+                if (it == enumValues.end()) {
+                    out = {};
+                    return true;
+                }
+                out = it->second;
+                return true;
+            }
+
+            if (auto actualType = getDataType(value); actualType != Flag) {
+                context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{Flag});
+                out = {};
+                return false;
+            }
+            auto s = value.get<EnumType>();
+            auto it = std::ranges::find_if(enumValues, [s](const auto &pair) {
+                return pair.first == s;
+            });
+            bool ok = it != enumValues.end();
+            out = ok ? it->second : T{};
+
+            if (!ok) {
+                std::vector<std::any> a;
+                for (auto &pair : enumValues) {
+                    a.push_back(pair.first);
+                }
+                context.errors.addError<EnumConstraintViolationError>(context.path, out, std::move(a));
+                return false;
+            }
+            return true;
+        }
+
+        std::array<std::pair<K, T>, N> enumValues;
+    };
+
+    template <typename T, auto fromJson>
+    bool fromJsonArrayHelper(const nlohmann::json &json, std::vector<T> &list, const JsonSerializationContext &context) {
+        list.clear();
+        auto &errors = context.errors;
+        auto options = context.options;
+        if (auto actualType = getDataType(json); (options & Serializer::CheckError) && actualType != InvalidDataTypeError::Array) {
+            errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Array});
+            return false;
+        }
+        const auto &array = json.is_array() ? json : nlohmann::json::array();
+        bool ok = true;
+        for (auto it = array.begin(); it != array.end(); ++it) {
+            auto index = std::distance(array.begin(), it);
+            T v{};
+            ok = fromJson(*it, v, JsonSerializationContext{context.errors, context.options, context.path + "[" + std::to_string(index) + "]"}) && ok;
+            if ((options & Serializer::FailFast) && errors.containsError()) {
+                return false;
+            }
+            list.push_back(std::move(v));
+        }
+        if (!(context.options & Serializer::CheckError))
+            return true;
+        return ok;
+    }
+
+    inline bool fromJsonObjectHelper(const nlohmann::json &value, nlohmann::json &out, const JsonSerializationContext &context) {
+        if (!(context.options & Serializer::CheckError)) {
+            out = value.is_object() ? value : nlohmann::json::object();
+            return true;
+        }
+        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Object) {
+            context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Object});
+            out = nlohmann::json::object();
+            return false;
+        }
+        out = value;
+        return true;
+    }
+
+    template <size_t N>
+    struct fromJsonObjectHelperWithPropertyCheck {
+        explicit fromJsonObjectHelperWithPropertyCheck(std::array<const char *, N> &&properties) : properties(properties) {
+        }
+
+        bool operator()(const nlohmann::json &value, nlohmann::json &out, const JsonSerializationContext &context) const {
+            if (!(context.options & Serializer::CheckError)) {
+                out = value.is_object() ? value : nlohmann::json::object();
+                return true;
+            }
+            if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Object) {
+                context.errors.addError<InvalidDataTypeError>(context.path, actualType, std::vector{InvalidDataTypeError::Object});
+                out = nlohmann::json::object();
+                return false;
+            }
+            const auto &obj = value;
+            std::vector<std::string> missingProperties;
+            std::vector<std::string> redundantProperties;
+            for (auto &property : properties) {
+                if (!obj.contains(property)) {
+                    missingProperties.push_back(property);
+                }
+            }
+            if (!missingProperties.empty()) {
+                context.errors.addError<MissingPropertyError>(context.path, std::move(missingProperties));
+            }
+            if (!(context.options & Serializer::TolerateRedundantProperty) && obj.size() + missingProperties.size() > properties.size()) {
+                for (auto it = obj.begin(); it != obj.end(); ++it) {
+                    if (!std::ranges::any_of(properties, [it](const auto &property) {
+                        return it.key() == property;
+                    })) {
+                        redundantProperties.push_back(it.key());
+                    }
+                }
+                context.errors.addError<RedundantPropertyError>(context.path, std::move(redundantProperties));
+            }
+            out = obj;
+            return missingProperties.empty() && ((context.options & Serializer::TolerateRedundantProperty) || redundantProperties.empty());
+        }
+
+        std::array<const char *, N> properties;
+    };
+
+}
+
+#endif //OPENDSPX_SERIALIZATION_HELPERS_P_H
diff --git a/include/opendspxserializer/private/sourcehelpers_p.h b/include/opendspxserializer/private/sourcehelpers_p.h
new file mode 100644
index 0000000..830abba
--- /dev/null
+++ b/include/opendspxserializer/private/sourcehelpers_p.h
@@ -0,0 +1,134 @@
+#ifndef OPENDSPX_SERIALIZER_SOURCEHELPERS_P_H
+#define OPENDSPX_SERIALIZER_SOURCEHELPERS_P_H
+
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include <opendspx/mixedsinger.h>
+#include <opendspx/sources.h>
+#include <opendspx/sourcemixingratio.h>
+#include <opendspxserializer/private/helpers_p.h>
+#include <opendspxserializer/serializationerror.h>
+
+namespace opendspx::impl {
+
+	struct SourceMixingRatioConvert {
+		template <typename T>
+		static constexpr auto getFromJsonFunc() {
+			if constexpr (std::is_same_v<T, SourceMixingRatio>) {
+				return [](const nlohmann::json &value, SourceMixingRatio &out, const JsonSerializationContext &context) {
+					std::vector<double> ratios;
+					bool ok = fromJsonArrayHelper<double, fromJsonDoubleHelperWithConstraint<0, 1>>(value, ratios, context);
+					out.assign(ratios.begin(), ratios.end());
+
+					if (!(context.options & Serializer::CheckError)) {
+						return true;
+					}
+
+					if (!out.valid()) {
+						context.errors.addError<InvalidRatioPartitionError>(context.path, ratios);
+						ok = false;
+					}
+					return ok;
+				};
+			} else {
+				static_assert(sizeof(T) == 0, "Unsupported type");
+			}
+		}
+
+		template <typename T>
+		static constexpr auto getToJsonFunc() {
+		    if constexpr (std::is_same_v<T, SourceMixingRatio>) {
+		        return [](nlohmann::json &json, const SourceMixingRatio &value, const JsonSerializationContext &context) {
+					std::vector<double> ratios(value.begin(), value.end());
+					bool ok = toJsonArrayHelper<double, toJsonNumberHelperWithConstraint<double, 0, 1>>(json, ratios, context);
+
+					if (!(context.options & Serializer::CheckError)) {
+						return true;
+					}
+
+					if (!value.valid()) {
+						context.errors.addError<InvalidRatioPartitionError>(context.path, ratios);
+						ok = false;
+					}
+					return ok;
+		        };
+		    } else {
+		        static_assert(sizeof(T) == 0, "Unsupported type");
+		    }
+		}
+	};
+
+    struct EntityWithRatioPostCheck {
+
+        template <typename T>
+        static bool fromJson(const nlohmann::json &object, T &entity, const JsonSerializationContext &context) {
+			(void) object;
+			return checkConstraint(entity, context);
+        }
+
+        template <typename T>
+        static bool toJson(nlohmann::json &object, const T &entity, const JsonSerializationContext &context) {
+			(void) object;
+			return checkConstraint(entity, context);
+        }
+
+	private:
+		static bool checkConstraint(const MixedSinger &entity, const JsonSerializationContext &context) {
+			if (!(context.options & Serializer::CheckError)) {
+				return true;
+			}
+			if (entity.singers.empty()) {
+				context.errors.addError<EmptySingerMixingError>(context.path + ".singers");
+				if (context.options & Serializer::FailFast) {
+					return false;
+				}
+			}
+			const auto expectedPartCount = static_cast<int>(entity.singers.size());
+			const auto actualPartCount = static_cast<int>(entity.ratio.size()) + 1;
+			if (expectedPartCount == actualPartCount) {
+				return true;
+			}
+			context.errors.addError<PartCountNotMatchError>(context.path + ".ratio", expectedPartCount, actualPartCount);
+			return false;
+		}
+
+		static bool checkConstraint(const Sources &entity, const JsonSerializationContext &context) {
+			if (!(context.options & Serializer::CheckError)) {
+				return true;
+			}
+			if (entity.singers.empty()) {
+				context.errors.addError<EmptySingerMixingError>(context.path + ".singers");
+				if (context.options & Serializer::FailFast) {
+					return false;
+				}
+			}
+			bool ok = true;
+			const auto expectedPartCount = static_cast<int>(entity.singers.size());
+			for (auto it = entity.mix.begin(); it != entity.mix.end(); ++it) {
+				const auto index = std::distance(entity.mix.begin(), it);
+				const auto actualPartCount = static_cast<int>(it->ratio.size()) + 1;
+				if (expectedPartCount != actualPartCount) {
+					context.errors.addError<PartCountNotMatchError>(context.path + ".mix[" + std::to_string(index) + "].ratio", expectedPartCount, actualPartCount);
+					ok = false;
+					if (context.options & Serializer::FailFast) {
+						return false;
+					}
+				}
+			}
+			return ok;
+		}
+
+		template <typename T>
+		static bool checkConstraint(const T &, const JsonSerializationContext &) {
+			static_assert(sizeof(T) == 0, "Unsupported type");
+			return false;
+		}
+    };
+
+}
+
+#endif // OPENDSPX_SERIALIZER_SOURCEHELPERS_P_H
\ No newline at end of file
diff --git a/include/opendspxserializer/serializationerror.h b/include/opendspxserializer/serializationerror.h
index 608dfb6..545e27a 100644
--- a/include/opendspxserializer/serializationerror.h
+++ b/include/opendspxserializer/serializationerror.h
@@ -1,13 +1,12 @@
 #ifndef OPENDSPX_SERIALIZER_SERIALIZATIONERROR_H
 #define OPENDSPX_SERIALIZER_SERIALIZATIONERROR_H
 
-#include <QJsonParseError>
-#include <QList>
-#include <QSharedPointer>
-#include <QString>
-#include <QVariant>
+#include <any>
+#include <utility>
 
-namespace QDspx {
+#include <nlohmann/json.hpp>
+
+namespace opendspx {
 
     class SerializationError {
     public:
@@ -15,10 +14,14 @@ namespace QDspx {
             JsonParseFailure = 0x0001,
             JsonRootIsNotObject = 0x0002,
             UnrecognizedVersion = 0x0003,
+            CompressionFailure = 0x0041,
             InvalidDataType = 0x1001,
             InvalidObjectType = 0x1002,
             RangeConstraintViolation = 0x1101,
             EnumConstraintViolation = 0x1102,
+            InvalidRatioPartition = 0x11C1,
+            PartCountNotMatch = 0x11C2,
+            EmptySingerMixing = 0x11C3,
             MissingProperty = 0x1401,
             RedundantProperty = 0x1402,
             OverlappingItem = 0x2001,
@@ -49,18 +52,26 @@ namespace QDspx {
 
     };
 
-    using SerializationErrorRef = QSharedPointer<SerializationError>;
+    using SerializationErrorRef = std::shared_ptr<SerializationError>;
 
     class JsonParseFailureError : public SerializationError {
     public:
-        JsonParseFailureError(const QJsonParseError &error)
-            : SerializationError(JsonParseFailure), m_error(error) {
+        JsonParseFailureError(int code, std::size_t index, std::string message)
+            : SerializationError(JsonParseFailure), m_code(code), m_index(index), m_message(std::move(message)) {
+        }
+        int code() const {
+            return m_code;
+        }
+        std::size_t index() const {
+            return m_index;
         }
-        QJsonParseError error() const {
-            return m_error;
+        std::string message() const {
+            return m_message;
         }
     private:
-        QJsonParseError m_error;
+        int m_code;
+        std::size_t m_index;
+        std::string m_message;
     };
 
     class JsonRootIsNotObjectError : public SerializationError {
@@ -72,23 +83,37 @@ namespace QDspx {
 
     class UnrecognizedVersionError : public SerializationError {
     public:
-        UnrecognizedVersionError(const QString &actualVersion)
-            : SerializationError(UnrecognizedVersion), m_actualVersion(actualVersion), m_actualVersionFlag(0) {
+        UnrecognizedVersionError(std::string actualVersion)
+            : SerializationError(UnrecognizedVersion), m_actualVersion(std::move(actualVersion)), m_actualVersionFlag(0) {
         }
         UnrecognizedVersionError(int actualVersionFlag)
             : SerializationError(UnrecognizedVersion), m_actualVersionFlag(actualVersionFlag) {
         }
-        QString actualVersion() const {
+        std::string actualVersion() const {
             return m_actualVersion;
         }
         int actualVersionFlag() const {
             return m_actualVersionFlag;
         }
     private:
-        QString m_actualVersion;
+        std::string m_actualVersion;
         int m_actualVersionFlag;
     };
 
+    class CompressionFailureError : public SerializationError {
+    public:
+        explicit CompressionFailureError(std::string message)
+            : SerializationError(CompressionFailure), m_message(std::move(message)) {
+        }
+
+        std::string message() const {
+            return m_message;
+        }
+
+    private:
+        std::string m_message;
+    };
+
     class InvalidDataTypeError : public SerializationError {
     public:
         enum DataType {
@@ -101,215 +126,266 @@ namespace QDspx {
             Object,
         };
 
-        InvalidDataTypeError(const QString &path, DataType actualType, const QList<DataType> &expectedTypes)
-            : SerializationError(InvalidDataType), m_path(path), m_actualType(actualType), m_expectedTypes(expectedTypes) {
+        InvalidDataTypeError(std::string path, DataType actualType, std::vector<DataType> expectedTypes)
+            : SerializationError(InvalidDataType), m_path(std::move(path)), m_actualType(actualType), m_expectedTypes(std::move(expectedTypes)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
         DataType actualType() const {
             return m_actualType;
         }
-        QList<DataType> expectedTypes() const {
+        std::vector<DataType> expectedTypes() const {
             return m_expectedTypes;
         }
 
     private:
-        QString m_path;
+        std::string m_path;
         DataType m_actualType;
-        QList<DataType> m_expectedTypes;
+        std::vector<DataType> m_expectedTypes;
 
     };
 
     class InvalidObjectTypeError : public SerializationError {
     public:
-        InvalidObjectTypeError(const QString &path, const QString &actualType, const QStringList &expectedTypes)
-            : SerializationError(InvalidObjectType), m_path(path), m_actualType(actualType), m_expectedTypes(expectedTypes) {
+        InvalidObjectTypeError(std::string path, std::string actualType, std::vector<std::string> expectedTypes)
+            : SerializationError(InvalidObjectType), m_path(std::move(path)), m_actualType(std::move(actualType)), m_expectedTypes(std::move(expectedTypes)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QString actualType() const {
+        std::string actualType() const {
             return m_actualType;
         }
-        QStringList expectedTypes() const {
+        std::vector<std::string> expectedTypes() const {
             return m_expectedTypes;
         }
 
     private:
-        QString m_path;
-        QString m_actualType;
-        QStringList m_expectedTypes;
+        std::string m_path;
+        std::string m_actualType;
+        std::vector<std::string> m_expectedTypes;
     };
 
     class RangeConstraintViolationError : public SerializationError {
     public:
-        RangeConstraintViolationError(const QString &path, const QVariant &actualValue, const QVariant &expectedMinimum, const QVariant &expectedMaximum)
-            : SerializationError(RangeConstraintViolation), m_path(path), m_actualValue(actualValue), m_expectedMinimum(expectedMinimum), m_expectedMaximum(expectedMaximum) {
+        RangeConstraintViolationError(std::string path, std::any actualValue, std::any expectedMinimum, std::any expectedMaximum)
+            : SerializationError(RangeConstraintViolation), m_path(std::move(path)), m_actualValue(std::move(actualValue)), m_expectedMinimum(std::move(expectedMinimum)), m_expectedMaximum(std::move(expectedMaximum)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QVariant actualValue() const {
+        std::any actualValue() const {
             return m_actualValue;
         }
-        QVariant expectedMinimum() const {
+        std::any expectedMinimum() const {
             return m_expectedMinimum;
         }
-        QVariant expectedMaximum() const {
+        std::any expectedMaximum() const {
             return m_expectedMaximum;
         }
 
     private:
-        QString m_path;
-        QVariant m_actualValue;
-        QVariant m_expectedMinimum;
-        QVariant m_expectedMaximum;
+        std::string m_path;
+        std::any m_actualValue;
+        std::any m_expectedMinimum;
+        std::any m_expectedMaximum;
     };
 
     class EnumConstraintViolationError : public SerializationError {
     public:
-        EnumConstraintViolationError(const QString &path, const QVariant &actualEnumValue, const QVariantList &expectedEnumValues)
-            : SerializationError(EnumConstraintViolation), m_path(path), m_actualEnumValue(actualEnumValue), m_expectedEnumValues(expectedEnumValues) {
+        EnumConstraintViolationError(std::string path, std::any actualEnumValue, std::vector<std::any> expectedEnumValues)
+            : SerializationError(EnumConstraintViolation), m_path(std::move(path)), m_actualEnumValue(std::move(actualEnumValue)), m_expectedEnumValues(std::move(expectedEnumValues)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QVariant actualEnumValue() const {
+        std::any actualEnumValue() const {
             return m_actualEnumValue;
         }
-        QVariantList expectedEnumValues() const {
+        std::vector<std::any> expectedEnumValues() const {
             return m_expectedEnumValues;
         }
 
     private:
-        QString m_path;
-        QVariant m_actualEnumValue;
-        QVariantList m_expectedEnumValues;
+        std::string m_path;
+        std::any m_actualEnumValue;
+        std::vector<std::any> m_expectedEnumValues;
+    };
+
+    class InvalidRatioPartitionError : public SerializationError {
+    public:
+        InvalidRatioPartitionError(std::string path, std::vector<double> ratio)
+            : SerializationError(InvalidRatioPartition), m_path(std::move(path)), m_ratio(std::move(ratio)) {
+        }
+        std::string path() const {
+            return m_path;
+        }
+        std::vector<double> ratio() const {
+            return m_ratio;
+        }
+
+    private:
+        std::string m_path;
+        std::vector<double> m_ratio;
+    };
+
+    class EmptySingerMixingError : public SerializationError {
+    public:
+        EmptySingerMixingError(std::string path)
+            : SerializationError(EmptySingerMixing), m_path(std::move(path)) {
+        }
+        std::string path() const {
+            return m_path;
+        }
+    private:
+        std::string m_path;
+    };
+
+    class PartCountNotMatchError : public SerializationError {
+    public:
+        PartCountNotMatchError(std::string path, int expectedPartCount, int actualPartCount)
+            : SerializationError(PartCountNotMatch), m_path(std::move(path)), m_expectedPartCount(expectedPartCount), m_actualPartCount(actualPartCount) {
+        }
+
+        std::string path() const {
+            return m_path;
+        }
+        int expectedPartCount() const {
+            return m_expectedPartCount;
+        }
+        int actualPartCount() const {
+            return m_actualPartCount;
+        }
+
+    private:
+        std::string m_path;
+        int m_expectedPartCount;
+        int m_actualPartCount;
     };
 
     class MissingPropertyError : public SerializationError {
     public:
-        MissingPropertyError(const QString &path, const QStringList &missingProperties)
-            : SerializationError(MissingProperty), m_path(path), m_missingProperties(missingProperties) {
+        MissingPropertyError(std::string path, std::vector<std::string> missingProperties)
+            : SerializationError(MissingProperty), m_path(std::move(path)), m_missingProperties(std::move(missingProperties)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QStringList missingProperties() const {
+        std::vector<std::string> missingProperties() const {
             return m_missingProperties;
         }
 
     private:
-        QString m_path;
-        QStringList m_missingProperties;
+        std::string m_path;
+        std::vector<std::string> m_missingProperties;
     };
 
     class RedundantPropertyError : public SerializationError {
     public:
-        RedundantPropertyError(const QString &path, const QStringList &redundantProperties)
+        RedundantPropertyError(const std::string &path, const std::vector<std::string> &redundantProperties)
             : SerializationError(RedundantProperty), m_path(path), m_redundantProperties(redundantProperties) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QStringList redundantProperties() const {
+        std::vector<std::string> redundantProperties() const {
             return m_redundantProperties;
         }
 
     private:
-        QString m_path;
-        QStringList m_redundantProperties;
+        std::string m_path;
+        std::vector<std::string> m_redundantProperties;
     };
 
     class OverlappingItemError : public SerializationError {
     public:
-        OverlappingItemError(const QString &path, const QList<int> &overlappedItemIndexes)
+        OverlappingItemError(const std::string &path, const std::vector<int> &overlappedItemIndexes)
             : SerializationError(OverlappingItem), m_path(path), m_overlappedItemIndexes(overlappedItemIndexes) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
-        QList<int> overlappedItemIndexes() const {
+        std::vector<int> overlappedItemIndexes() const {
             return m_overlappedItemIndexes;
         }
 
     private:
-        QString m_path;
-        QList<int> m_overlappedItemIndexes;
+        std::string m_path;
+        std::vector<int> m_overlappedItemIndexes;
     };
 
     class ZeroLengthRangeError : public SerializationError {
     public:
-        ZeroLengthRangeError(const QString &path)
-            : SerializationError(ZeroLengthRange), m_path(path) {
+        ZeroLengthRangeError(std::string path)
+            : SerializationError(ZeroLengthRange), m_path(std::move(path)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
 
     private:
-        QString m_path;
+        std::string m_path;
     };
 
     class ErroneousClipRangeError : public SerializationError {
     public:
-        ErroneousClipRangeError(const QString &path)
-            : SerializationError(ErroneousClipRange), m_path(path) {
+        ErroneousClipRangeError(std::string path)
+            : SerializationError(ErroneousClipRange), m_path(std::move(path)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
 
     private:
-        QString m_path;
+        std::string m_path;
     };
 
     class ErroneousClipPositionError : public SerializationError {
     public:
-        ErroneousClipPositionError(const QString &path)
-            : SerializationError(ErroneousClipPosition), m_path(path) {
+        ErroneousClipPositionError(std::string path)
+            : SerializationError(ErroneousClipPosition), m_path(std::move(path)) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
 
     private:
-        QString m_path;
+        std::string m_path;
     };
 
     class SafeRangeLimitExceededError : public SerializationError {
     public:
-        SafeRangeLimitExceededError(const QString &path)
+        SafeRangeLimitExceededError(const std::string &path)
             : SerializationError(SafeRangeLimitExceeded), m_path(path) {
         }
 
-        QString path() const {
+        std::string path() const {
             return m_path;
         }
 
     private:
-        QString m_path;
+        std::string m_path;
     };
 
-    class SerializationErrorList : public QList<SerializationErrorRef> {
+    class SerializationErrorList : public std::vector<SerializationErrorRef> {
     public:
-        using QList::QList;
+        using std::vector<SerializationErrorRef>::vector;
 
         template<typename T, typename... Args>
         void addError(Args &&... args) {
-            auto s = QSharedPointer<T>::create(std::forward<Args>(args)...);
-            append(s);
+            auto s = std::make_shared<T>(std::forward<Args>(args)...);
+            push_back(s);
             m_containsFatal = m_containsFatal || s->isFatal();
             m_containsError = m_containsError || s->isError();
             m_containsWarning = m_containsWarning || s->isWarning();
diff --git a/include/opendspxserializer/serializer.h b/include/opendspxserializer/serializer.h
index 7387c37..33788ec 100644
--- a/include/opendspxserializer/serializer.h
+++ b/include/opendspxserializer/serializer.h
@@ -1,14 +1,16 @@
 #ifndef OPENDSPX_SERIALIZER_SERIALIZER_H
 #define OPENDSPX_SERIALIZER_SERIALIZER_H
 
-#include <QSharedPointer>
+#include <iosfwd>
+
+#include <stdcorelib/flags.h>
 
 #include <opendspx/model.h>
 
 #include <opendspxserializer/opendspxserializerglobal.h>
 #include <opendspxserializer/serializationerror.h>
 
-namespace QDspx {
+namespace opendspx {
 
     class OPENDSPX_SERIALIZER_EXPORT Serializer {
     public:
@@ -18,16 +20,16 @@ namespace QDspx {
             TolerateRedundantProperty = 0x0004,
             CheckWarning = 0x0008,
         };
-        Q_DECLARE_FLAGS(Option, OptionFlag)
+        STDC_DECLARE_FLAGS(Option, OptionFlag)
 
-        static QString versionToText(Model::Version version);
-        static Model::Version versionFromText(const QString &text, bool *ok = nullptr);
+        static std::string versionToText(Model::Version version);
+        static Model::Version versionFromText(const std::string &text, bool *ok = nullptr);
 
-        static QByteArray serialize(const Model &model, SerializationErrorList &errors, Option options = {FailFast | CheckError});
-        static Model deserialize(const QByteArray &data, SerializationErrorList &errors, Option options = {FailFast | CheckError});
+        static void serialize(std::ostream &out, const Model &model, SerializationErrorList &errors, Option options = {Option(FailFast) | Option(CheckError)}, bool compress = false);
+        static Model deserialize(std::istream &in, SerializationErrorList &errors, Option options = {Option(FailFast) | Option(CheckError)});
     };
 
-    Q_DECLARE_OPERATORS_FOR_FLAGS(Serializer::Option)
+    STDC_DECLARE_OPERATORS_FOR_FLAGS(Serializer::Option)
 
 }
 
diff --git a/opendspxConfig.cmake.in b/opendspxConfig.cmake.in
index ed97e90..9605be7 100644
--- a/opendspxConfig.cmake.in
+++ b/opendspxConfig.cmake.in
@@ -2,7 +2,4 @@
 
 include(CMakeFindDependencyMacro)
 
-find_dependency(QT NAMES Qt6 Qt5 COMPONENTS Core REQUIRED)
-find_dependency(Qt${QT_VERSION_MAJOR} COMPONENTS Core REQUIRED)
-
 include("${CMAKE_CURRENT_LIST_DIR}/opendspxTargets.cmake")
\ No newline at end of file
diff --git a/src/converter/midiconverter.cpp b/src/converter/midiconverter.cpp
index 57fdc6d..b5dbc2f 100644
--- a/src/converter/midiconverter.cpp
+++ b/src/converter/midiconverter.cpp
@@ -1,27 +1,25 @@
 #include "midi/midiconverter.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <ranges>
 #include <deque>
 #include <map>
-#include <sstream>
 #include <vector>
 #include <utility>
-#include <istream>
 
 #include <wolf-midi/MidiFile.h>
 
 #include <opendspx/model.h>
 #include <opendspxconverter/midi/midiintermediatedata.h>
 
-namespace QDspx {
+namespace opendspx {
 
     constexpr int kDspxTicksPerQuarter = 480;
 
-    MidiIntermediateData MidiConverter::convertMidiToIntermediate(const QByteArray &midiData, Error &error, ConvertMidiToIntermediateOption option) {
+    MidiIntermediateData MidiConverter::convertMidiToIntermediate(std::istream &in, Error &error, ConvertMidiToIntermediateOption option) {
         error = Error::NoError;
 
-        std::istringstream in(std::string(midiData.constData(), midiData.size()), std::ios::binary);
         Midi::MidiFile midiFile;
         if (!midiFile.load(in)) {
             error = Error::InvalidMidiData;
@@ -42,20 +40,20 @@ namespace QDspx {
 
         midiFile.sort();
 
-        QList<MidiIntermediateData::Tempo> tempos;
-        QList<MidiIntermediateData::TimeSignature> timeSignatures;
-        QList<MidiIntermediateData::Marker> markers;
-        QList<MidiIntermediateData::Track> tracks;
+        std::vector<MidiIntermediateData::Tempo> tempos;
+        std::vector<MidiIntermediateData::TimeSignature> timeSignatures;
+        std::vector<MidiIntermediateData::Marker> markers;
+        std::vector<MidiIntermediateData::Track> tracks;
 
         const bool separateChannels = option.separateChannels;
 
         for (int trackId : midiFile.tracks()) {
             const auto events = midiFile.eventsForTrack(trackId);
-            QByteArray trackTitle;
+            std::string trackTitle;
 
             struct LyricEvent {
                 int tick;
-                QByteArray text;
+                std::string text;
             };
             std::vector<LyricEvent> lyricEvents;
 
@@ -68,14 +66,14 @@ namespace QDspx {
                 const int scaledTick = event->tick();
                 switch (event->number()) {
                     case Midi::MidiEvent::TrackName: {
-                        if (trackTitle.isEmpty()) {
+                        if (trackTitle.empty()) {
                             const auto data = event->data();
-                            trackTitle = QByteArray(data.data(), static_cast<int>(data.size()));
+                            trackTitle = std::string(data.data(), static_cast<int>(data.size()));
                         }
                         break;
                     }
                     case Midi::MidiEvent::Tempo: {
-                        tempos.append({scaledTick, static_cast<double>(event->tempo())});
+                        tempos.emplace_back(scaledTick, static_cast<double>(event->tempo()));
                         break;
                     }
                     case Midi::MidiEvent::TimeSignature: {
@@ -83,18 +81,18 @@ namespace QDspx {
                         if (data.size() >= 2) {
                             const int numerator = static_cast<unsigned char>(data[0]);
                             const int denominator = 1 << static_cast<unsigned char>(data[1]);
-                            timeSignatures.append({scaledTick, numerator, denominator});
+                            timeSignatures.emplace_back(scaledTick, numerator, denominator);
                         }
                         break;
                     }
                     case Midi::MidiEvent::Marker: {
                         const auto data = event->data();
-                        markers.append({scaledTick, QByteArray(data.data(), static_cast<int>(data.size()))});
+                        markers.emplace_back(scaledTick, std::string(data.data(), static_cast<int>(data.size())));
                         break;
                     }
                     case Midi::MidiEvent::Lyric: {
                         const auto data = event->data();
-                        lyricEvents.push_back({scaledTick, QByteArray(data.data(), static_cast<int>(data.size()))});
+                        lyricEvents.emplace_back(scaledTick, std::string(data.data(), static_cast<int>(data.size())));
                         break;
                     }
                     default:
@@ -104,13 +102,13 @@ namespace QDspx {
 
             struct PendingNote {
                 int startTick;
-                QByteArray lyric;
+                std::string lyric;
             };
 
             // channel -> key -> FIFO notes (to support overlapping notes on same key)
             std::map<int, std::map<int, std::deque<PendingNote>>> pendingNotes;
-            QList<MidiIntermediateData::Note> combinedNotes;
-            std::map<int, QList<MidiIntermediateData::Note>> channelNotes; // channel -> notes
+            std::vector<MidiIntermediateData::Note> combinedNotes;
+            std::map<int, std::vector<MidiIntermediateData::Note>> channelNotes; // channel -> notes
 
             std::size_t lyricIndex = 0;
 
@@ -152,9 +150,9 @@ namespace QDspx {
                     if (length >= 0) {
                         MidiIntermediateData::Note note{pending.startTick, length, key, pending.lyric};
                         if (separateChannels) {
-                            channelNotes[channel].append(note);
+                            channelNotes[channel].push_back(note);
                         } else {
-                            combinedNotes.append(note);
+                            combinedNotes.push_back(note);
                         }
                     }
 
@@ -167,7 +165,7 @@ namespace QDspx {
                     continue;
                 }
 
-                QByteArray lyric;
+                std::string lyric;
                 if (lyricIndex < lyricEvents.size() && lyricEvents[lyricIndex].tick <= scaledTick) {
                     lyric = lyricEvents[lyricIndex].text;
                     ++lyricIndex;
@@ -178,10 +176,10 @@ namespace QDspx {
 
             if (separateChannels) {
                 for (auto &channelPair : channelNotes) {
-                    tracks.append({trackTitle, channelPair.second, channelPair.first, midiFile.trackEndTick(trackId)});
+                    tracks.emplace_back(trackTitle, channelPair.second, channelPair.first, midiFile.trackEndTick(trackId));
                 }
             } else {
-                tracks.append({trackTitle, combinedNotes, -1, midiFile.trackEndTick(trackId)});
+                tracks.emplace_back(trackTitle, combinedNotes, -1, midiFile.trackEndTick(trackId));
             }
         }
 
@@ -189,10 +187,10 @@ namespace QDspx {
     }
 
     Model MidiConverter::convertIntermediateToDspx(const MidiIntermediateData &midiData, bool *ok) {
-        return convertIntermediateToDspx(midiData, [](const QByteArray &data) { return QString::fromUtf8(data); }, ok);
+        return convertIntermediateToDspx(midiData, [](const std::string &data) { return data; }, ok);
     }
 
-    Model MidiConverter::convertIntermediateToDspx(const MidiIntermediateData &midiData, const std::function<QString(const QByteArray &)> &decodeText, bool *ok) {
+    Model MidiConverter::convertIntermediateToDspx(const MidiIntermediateData &midiData, const std::function<std::string(const std::string &)> &decodeText, bool *ok) {
         if (ok) {
             *ok = false;
         }
@@ -207,21 +205,21 @@ namespace QDspx {
         }
 
         const auto scaleTick = [srcResolution](int tick) -> int {
-            return static_cast<int>(static_cast<qint64>(tick) * kDspxTicksPerQuarter / srcResolution);
+            return static_cast<int>(static_cast<std::int64_t>(tick) * kDspxTicksPerQuarter / srcResolution);
         };
 
         Model model;
 
-        QList<Tempo> tempos;
+        std::vector<Tempo> tempos;
         const auto midiTempos = midiData.tempos();
         const bool hasInitialTempo = std::ranges::any_of(midiTempos, [](const auto &tempo) {
             return tempo.tick == 0;
         });
         if (!hasInitialTempo) {
-            tempos.append({0, 120.0});
+            tempos.emplace_back(0, 120.0);
         }
         for (const auto &tempo : midiTempos) {
-            tempos.append({scaleTick(tempo.tick), tempo.tempo});
+            tempos.emplace_back(scaleTick(tempo.tick), tempo.tempo);
         }
 
         auto midiTimeSignatures = midiData.timeSignatures();
@@ -229,39 +227,39 @@ namespace QDspx {
             return sig.tick == 0;
         });
         if (!hasInitialTimeSignature) {
-            midiTimeSignatures.prepend({0, 4, 4});
+            midiTimeSignatures.insert(midiTimeSignatures.begin(), {0, 4, 4});
         }
         std::ranges::stable_sort(midiTimeSignatures, [](const auto &lhs, const auto &rhs) {
             return lhs.tick < rhs.tick;
         });
 
-        QList<TimeSignature> timeSignatures;
-        if (!midiTimeSignatures.isEmpty()) {
+        std::vector<TimeSignature> timeSignatures;
+        if (!midiTimeSignatures.empty()) {
             const auto &firstSignature = midiTimeSignatures.front();
-            timeSignatures.append({0, firstSignature.numerator, firstSignature.denominator});
+            timeSignatures.emplace_back(0, firstSignature.numerator, firstSignature.denominator);
 
             int currentNumerator = firstSignature.numerator;
             int currentDenominator = firstSignature.denominator;
-            qint64 currentMeasureStartTick = 0;
+            std::int64_t currentMeasureStartTick = 0;
             int currentMeasureIndex = 0;
 
-            const auto ticksPerMeasure = [srcResolution](int numerator, int denominator) -> qint64 {
-                return static_cast<qint64>(numerator) * srcResolution * 4 / denominator;
+            const auto ticksPerMeasure = [srcResolution](int numerator, int denominator) -> std::int64_t {
+                return static_cast<std::int64_t>(numerator) * srcResolution * 4 / denominator;
             };
 
             for (int i = 1; i < midiTimeSignatures.size(); ++i) {
                 const auto &signature = midiTimeSignatures.at(i);
-                const qint64 measureTicks = ticksPerMeasure(currentNumerator, currentDenominator);
+                const std::int64_t measureTicks = ticksPerMeasure(currentNumerator, currentDenominator);
                 if (measureTicks <= 0) {
                     continue;
                 }
 
-                qint64 deltaTicks = static_cast<qint64>(signature.tick) - currentMeasureStartTick;
+                std::int64_t deltaTicks = static_cast<std::int64_t>(signature.tick) - currentMeasureStartTick;
                 if (deltaTicks < 0) {
                     deltaTicks = 0;
                 }
 
-                qint64 measuresForward = deltaTicks / measureTicks;
+                std::int64_t measuresForward = deltaTicks / measureTicks;
                 if (deltaTicks % measureTicks != 0) {
                     ++measuresForward;
                 }
@@ -269,11 +267,11 @@ namespace QDspx {
                 currentMeasureIndex += static_cast<int>(measuresForward);
                 currentMeasureStartTick += measuresForward * measureTicks;
 
-                if (!timeSignatures.isEmpty() && timeSignatures.back().index == currentMeasureIndex) {
+                if (!timeSignatures.empty() && timeSignatures.back().index == currentMeasureIndex) {
                     timeSignatures.back().numerator = signature.numerator;
                     timeSignatures.back().denominator = signature.denominator;
                 } else {
-                    timeSignatures.append({currentMeasureIndex, signature.numerator, signature.denominator});
+                    timeSignatures.emplace_back(currentMeasureIndex, signature.numerator, signature.denominator);
                 }
 
                 currentNumerator = signature.numerator;
@@ -281,9 +279,9 @@ namespace QDspx {
             }
         }
 
-        QList<Label> labels;
+        std::vector<Label> labels;
         for (const auto &marker : midiData.markers()) {
-            labels.append({scaleTick(marker.tick), decodeText(marker.text)});
+            labels.emplace_back(scaleTick(marker.tick), decodeText(marker.text));
         }
 
         model.content.timeline.tempos = std::move(tempos);
@@ -294,7 +292,7 @@ namespace QDspx {
             Track dspxTrack;
             dspxTrack.name = decodeText(track.title);
 
-            QList<Note> notes;
+            std::vector<Note> notes;
             notes.reserve(track.notes.size());
             for (const auto &note : track.notes) {
                 Note dspxNote;
@@ -302,16 +300,16 @@ namespace QDspx {
                 dspxNote.length = scaleTick(note.length);
                 dspxNote.keyNum = note.key;
                 dspxNote.lyric = decodeText(note.lyric);
-                notes.append(std::move(dspxNote));
+                notes.push_back(std::move(dspxNote));
             }
 
-            auto clip = QSharedPointer<SingingClip>::create();
+            auto clip = std::make_shared<SingingClip>();
             clip->name = dspxTrack.name;
             clip->notes = std::move(notes);
             clip->time.clipLen = scaleTick(track.endTick);
 
-            dspxTrack.clips.append(clip);
-            model.content.tracks.append(dspxTrack);
+            dspxTrack.clips.push_back(clip);
+            model.content.tracks.push_back(dspxTrack);
         }
 
         if (ok) {
@@ -320,28 +318,28 @@ namespace QDspx {
         return model;
     }
     MidiIntermediateData MidiConverter::convertDspxToIntermediate(const Model &model, ConvertDspxToIntermediateOption option) {
-        return convertDspxToIntermediate(model, [](const QString &text) { return text.toUtf8(); }, option);
+        return convertDspxToIntermediate(model, [](const std::string &text) { return text; }, option);
     }
 
-    MidiIntermediateData MidiConverter::convertDspxToIntermediate(const Model &model, const std::function<QByteArray(const QString &)> &encodeText, ConvertDspxToIntermediateOption option) {
+    MidiIntermediateData MidiConverter::convertDspxToIntermediate(const Model &model, const std::function<std::string(const std::string &)> &encodeText, ConvertDspxToIntermediateOption option) {
         if (option.resolution <= 0) {
             return {};
         }
 
-        const auto scaleTick = [resolution = option.resolution](qint64 tick) -> int {
+        const auto scaleTick = [resolution = option.resolution](std::int64_t tick) -> int {
             return static_cast<int>(tick * resolution / kDspxTicksPerQuarter);
         };
 
-        QList<MidiIntermediateData::Tempo> tempos;
+        std::vector<MidiIntermediateData::Tempo> tempos;
         const auto &timeline = model.content.timeline;
         const bool hasInitialTempo = std::ranges::any_of(timeline.tempos, [](const auto &tempo) {
             return tempo.pos == 0;
         });
         if (!hasInitialTempo) {
-            tempos.append({0, 120.0});
+            tempos.emplace_back(0, 120.0);
         }
         for (const auto &tempo : timeline.tempos) {
-            tempos.append({scaleTick(tempo.pos), tempo.value});
+            tempos.emplace_back(scaleTick(tempo.pos), tempo.value);
         }
 
         auto timeSignaturesSrc = timeline.timeSignatures;
@@ -349,36 +347,36 @@ namespace QDspx {
             return signature.index == 0;
         });
         if (!hasInitialTimeSignature) {
-            timeSignaturesSrc.prepend({0, 4, 4});
+            timeSignaturesSrc.insert(timeSignaturesSrc.begin(), {0, 4, 4});
         }
         std::ranges::stable_sort(timeSignaturesSrc, [](const auto &lhs, const auto &rhs) {
             return lhs.index < rhs.index;
         });
 
-        QList<MidiIntermediateData::TimeSignature> timeSignatures;
-        if (!timeSignaturesSrc.isEmpty()) {
+        std::vector<MidiIntermediateData::TimeSignature> timeSignatures;
+        if (!timeSignaturesSrc.empty()) {
             int currentNumerator = 4;
             int currentDenominator = 4;
             int currentIndex = 0;
-            qint64 currentTick = 0;
+            std::int64_t currentTick = 0;
 
-            const auto ticksPerMeasure = [resolution = option.resolution](int numerator, int denominator) -> qint64 {
-                return static_cast<qint64>(numerator) * resolution * 4 / denominator;
+            const auto ticksPerMeasure = [resolution = option.resolution](int numerator, int denominator) -> std::int64_t {
+                return static_cast<std::int64_t>(numerator) * resolution * 4 / denominator;
             };
 
             for (const auto &signature : timeSignaturesSrc) {
-                const qint64 measureTicks = ticksPerMeasure(currentNumerator, currentDenominator);
+                const std::int64_t measureTicks = ticksPerMeasure(currentNumerator, currentDenominator);
                 if (measureTicks <= 0) {
                     continue;
                 }
 
-                qint64 measuresForward = static_cast<qint64>(signature.index) - currentIndex;
+                std::int64_t measuresForward = static_cast<std::int64_t>(signature.index) - currentIndex;
                 if (measuresForward < 0) {
                     measuresForward = 0;
                 }
 
-                const qint64 signatureTick = currentTick + measuresForward * measureTicks;
-                timeSignatures.append({scaleTick(signatureTick), signature.numerator, signature.denominator});
+                const std::int64_t signatureTick = currentTick + measuresForward * measureTicks;
+                timeSignatures.emplace_back(scaleTick(signatureTick), signature.numerator, signature.denominator);
 
                 currentIndex = signature.index;
                 currentTick = signatureTick;
@@ -387,73 +385,76 @@ namespace QDspx {
             }
         }
 
-        QList<MidiIntermediateData::Marker> markers;
+        std::vector<MidiIntermediateData::Marker> markers;
         for (const auto &label : timeline.labels) {
-            markers.append({scaleTick(label.pos), encodeText(label.text)});
+            markers.emplace_back(scaleTick(label.pos), encodeText(label.text));
         }
 
-        QList<MidiIntermediateData::Track> tracks;
+        std::vector<MidiIntermediateData::Track> tracks;
         for (const auto &track : model.content.tracks) {
-            QList<SingingClip> singingClips;
+            std::vector<SingingClip> singingClips;
             for (const auto &clipRef : track.clips) {
-                if (!clipRef || clipRef->type != Clip::Singing) {
+                if (!clipRef || clipRef->type != Clip::Type::Singing) {
                     continue;
                 }
-                const auto singingClip = qSharedPointerCast<SingingClip>(clipRef);
+                const auto singingClip = std::static_pointer_cast<SingingClip>(clipRef);
                 if (!singingClip) {
                     continue;
                 }
-                singingClips.append(*singingClip);
+                singingClips.push_back(*singingClip);
             }
 
             if (option.separateClips) {
                 for (const auto &clip : singingClips) {
-                    QList<MidiIntermediateData::Note> notes;
-                    qint64 trackEndTick = 0;
+                    std::vector<MidiIntermediateData::Note> notes;
+                    std::int64_t trackEndTick = 0;
+
+                    const std::int64_t start = static_cast<std::int64_t>(clip.time.pos) - clip.time.clipStart;
 
                     for (const auto &note : clip.notes) {
-                        const qint64 noteStart = static_cast<qint64>(clip.time.start) + note.pos;
-                        const qint64 noteEnd = noteStart + note.length;
-                        notes.append({scaleTick(noteStart), scaleTick(note.length), note.keyNum, encodeText(note.lyric)});
+                        const std::int64_t noteStart = start + note.pos;
+                        const std::int64_t noteEnd = noteStart + note.length;
+                        notes.emplace_back(scaleTick(noteStart), scaleTick(note.length), note.keyNum, encodeText(note.lyric));
                         trackEndTick = std::max(trackEndTick, noteEnd);
                     }
 
-                    trackEndTick = std::max(trackEndTick, static_cast<qint64>(clip.time.start) + clip.time.clipLen);
+                    trackEndTick = std::max(trackEndTick, start + clip.time.clipLen);
 
-                    QString name = track.name;
-                    if (!clip.name.isEmpty()) {
-                        if (!name.isEmpty()) {
-                            name.append(' ');
+                    std::string name = track.name;
+                    if (!clip.name.empty()) {
+                        if (!name.empty()) {
+                            name.append({' '});
                         }
                         name.append(clip.name);
                     }
 
-                    tracks.append({encodeText(name), notes, -1, scaleTick(trackEndTick)});
+                    tracks.emplace_back(encodeText(name), notes, -1, scaleTick(trackEndTick));
                 }
             } else {
-                QList<MidiIntermediateData::Note> notes;
-                qint64 trackEndTick = 0;
+                std::vector<MidiIntermediateData::Note> notes;
+                std::int64_t trackEndTick = 0;
 
                 for (const auto &clip : singingClips) {
+                    const std::int64_t start = static_cast<std::int64_t>(clip.time.pos) - clip.time.clipStart;
                     for (const auto &note : clip.notes) {
-                        const qint64 noteStart = static_cast<qint64>(clip.time.start) + note.pos;
-                        const qint64 noteEnd = noteStart + note.length;
-                        notes.append({scaleTick(noteStart), scaleTick(note.length), note.keyNum, encodeText(note.lyric)});
+                        const std::int64_t noteStart = start + note.pos;
+                        const std::int64_t noteEnd = noteStart + note.length;
+                        notes.emplace_back(scaleTick(noteStart), scaleTick(note.length), note.keyNum, encodeText(note.lyric));
                         trackEndTick = std::max(trackEndTick, noteEnd);
                     }
-                    trackEndTick = std::max(trackEndTick, static_cast<qint64>(clip.time.start) + clip.time.clipLen);
+                    trackEndTick = std::max(trackEndTick, start + clip.time.clipLen);
                 }
 
-                tracks.append({encodeText(track.name), notes, -1, scaleTick(trackEndTick)});
+                tracks.emplace_back(encodeText(track.name), notes, -1, scaleTick(trackEndTick));
             }
         }
 
         return {option.resolution, tempos, timeSignatures, markers, tracks};
     }
 
-    QByteArray MidiConverter::convertIntermediateToMidi(const MidiIntermediateData &midiData) {
+    void MidiConverter::convertIntermediateToMidi(std::ostream &out, const MidiIntermediateData &midiData) {
         if (!midiData.isValid() || midiData.resolution() <= 0) {
-            return {};
+            return;
         }
 
         Midi::MidiFile midiFile;
@@ -477,7 +478,7 @@ namespace QDspx {
         for (const auto &track : midiData.tracks()) {
             const int trackId = midiFile.createTrack();
 
-            if (!track.title.isEmpty()) {
+            if (!track.title.empty()) {
                 midiFile.createMetaEvent(trackId, 0, Midi::MidiEvent::TrackName, std::vector<char>(track.title.begin(), track.title.end()));
             }
 
@@ -486,7 +487,7 @@ namespace QDspx {
             for (const auto &note : track.notes) {
                 const int noteOffTick = note.noteOnTick + note.length;
 
-                if (!note.lyric.isEmpty()) {
+                if (!note.lyric.empty()) {
                     midiFile.createLyricEvent(trackId, note.noteOnTick, std::vector<char>(note.lyric.begin(), note.lyric.end()));
                 }
 
@@ -497,13 +498,7 @@ namespace QDspx {
 
         midiFile.sort();
 
-        std::ostringstream out(std::ios::binary);
-        if (!midiFile.save(out)) {
-            return {};
-        }
-
-        const std::string str = out.str();
-        return QByteArray(str.data(), static_cast<int>(str.size()));
+        midiFile.save(out);
     }
 
 }
diff --git a/src/serializer/converterhelperfromjson_p.h b/src/serializer/converterhelperfromjson_p.h
deleted file mode 100644
index dcd01d9..0000000
--- a/src/serializer/converterhelperfromjson_p.h
+++ /dev/null
@@ -1,290 +0,0 @@
-#ifndef OPENDSPX_SERIALIZATION_CONVERTERHELPER_P_H
-#define OPENDSPX_SERIALIZATION_CONVERTERHELPER_P_H
-
-#include "serializationerror.h"
-#include "serializer.h"
-#include <algorithm>
-#include <array>
-#include <limits>
-
-#include <QJsonArray>
-#include <QJsonObject>
-
-#ifndef FAIL_FAST_RETURN
-#define FAIL_FAST_RETURN(ret) \
-    do { \
-        if ((options & Serializer::FailFast) && errors.containsError()) { \
-            return ret; \
-        } \
-    } while (false)
-#endif
-
-#define FROM_JSON_FAIL_FAST(val, json, parseFunc, ret) \
-    do {\
-        FAIL_FAST_RETURN(ret); \
-        auto v = parseFunc(json, errors, options, path); \
-        FAIL_FAST_RETURN(ret); \
-        val = v; \
-    } while (false)
-
-#define FROM_JSON_PROPERTY_FAIL_FAST(entity, property, parseFunc, ret) \
-    do { \
-        if (!object.contains(#property)) \
-            break; /* Suppose that property existency has been checked with `fromJsonObjectHelper` */ \
-        FAIL_FAST_RETURN(ret); \
-        auto v = parseFunc(object.value(#property), errors, options, path + "."#property); \
-        FAIL_FAST_RETURN(ret); \
-        entity property = v; \
-    } while (false)
-
-namespace QDspx {
-
-    inline bool isInteger(double v) {
-        return std::isfinite(v) && std::trunc(v) == v && v >= std::numeric_limits<int>::min() && v <= std::numeric_limits<int>::max();
-    }
-
-    inline InvalidDataTypeError::DataType getDataType(const QJsonValue &value) {
-        switch (value.type()) {
-            case QJsonValue::Type::Bool:
-                return InvalidDataTypeError::Bool;
-            case QJsonValue::Type::Double:
-                return isInteger(value.toDouble()) ? InvalidDataTypeError::Integer : InvalidDataTypeError::Double;
-            case QJsonValue::Type::String:
-                return InvalidDataTypeError::String;
-            case QJsonValue::Type::Array:
-                return InvalidDataTypeError::Array;
-            case QJsonValue::Type::Object:
-                return InvalidDataTypeError::Object;
-            default:
-                return InvalidDataTypeError::Null;
-        }
-    }
-
-    inline QString fromJsonStringHelper(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        if (!(options & Serializer::CheckError)) {
-            return value.toString();
-        }
-        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::String) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::String});
-        }
-        return value.toString();
-    }
-
-    inline double fromJsonDoubleHelper(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        if (!(options & Serializer::CheckError)) {
-            return value.toDouble();
-        }
-        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Double && actualType != InvalidDataTypeError::Integer) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Double, InvalidDataTypeError::Integer});
-        }
-        return value.toDouble();
-    }
-
-    struct fromJsonDoubleHelperWithConstraint {
-        fromJsonDoubleHelperWithConstraint(double minimum, double maximum = std::numeric_limits<double>::lowest()) : maximum(maximum), minimum(minimum) {
-        }
-
-        double operator()(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            if (!(options & Serializer::CheckError)) {
-                return value.toDouble();
-            }
-            if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Double && actualType != InvalidDataTypeError::Integer) {
-                errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Double, InvalidDataTypeError::Integer});
-                return 0;
-            }
-            auto v = value.toDouble();
-            if (v < minimum || (maximum >= minimum && v > maximum)) {
-                auto maxVar = maximum >= minimum ? maximum : QVariant();
-                errors.addError<RangeConstraintViolationError>(path, v, minimum, maxVar);
-            }
-            return v;
-        }
-
-        double maximum;
-        double minimum;
-    };
-
-    inline int fromJsonIntHelper(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        if (!(options & Serializer::CheckError)) {
-            return value.toInt();
-        }
-        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Integer) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Integer});
-        }
-        return value.toInt();
-    }
-
-    struct fromJsonIntHelperWithConstraint {
-        fromJsonIntHelperWithConstraint(int minimum, int maximum = std::numeric_limits<int>::lowest()) : maximum(maximum), minimum(minimum) {
-        }
-
-        int operator()(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            if (!(options & Serializer::CheckError)) {
-                return value.toInt();
-            }
-            if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Integer) {
-                errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Integer});
-                return 0;
-            }
-            auto v = value.toInt();
-            if (v < minimum || (maximum >= minimum && v > maximum)) {
-                auto maxVar = maximum >= minimum ? maximum : QVariant();
-                errors.addError<RangeConstraintViolationError>(path, v, minimum, maxVar);
-            }
-            return v;
-        }
-
-        int maximum;
-        int minimum;
-    };
-
-    inline bool fromJsonBoolHelper(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        if (!(options & Serializer::CheckError)) {
-            return value.toBool();
-        }
-        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Bool) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Bool});
-        }
-        return value.toBool();
-    }
-
-    template <typename K, typename T, size_t N>
-    struct fromJsonEnumHelper {
-        static_assert(std::is_same_v<K, const char *> || std::is_same_v<K, int>);
-
-        fromJsonEnumHelper(const std::array<QPair<K, T>, N> &enumValues) : enumValues(enumValues) {
-        }
-
-        static constexpr InvalidDataTypeError::DataType Flag = std::is_same_v<K, const char *> ? InvalidDataTypeError::String : InvalidDataTypeError::Integer;
-
-        T operator()(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            if (!(options & Serializer::CheckError)) {
-                auto s = value.toVariant().value<K>();
-                auto it = std::ranges::find_if(enumValues, [s](const auto &pair) {
-                    return pair.first == s;
-                });
-                return it == enumValues.end() ? T{} : it->second;
-            }
-            if (auto actualType = getDataType(value); actualType != Flag) {
-                errors.addError<InvalidDataTypeError>(path, actualType, QList{Flag});
-                return {};
-            }
-            bool ok;
-            T ret;
-            if constexpr (std::is_same_v<K, const char *>) {
-                auto s = value.toString();
-                auto it = std::ranges::find_if(enumValues, [s](const auto &pair) {
-                    return pair.first == s;
-                });
-                ok = it != enumValues.end();
-                ret = ok ? it->second : T{};
-            } else {
-                auto s = value.toInt();
-                auto it = std::ranges::find_if(enumValues, [s](const auto &pair) {
-                    return pair.first == s;
-                });
-                ok = it != enumValues.end();
-                ret = ok ? it->second : T{};
-            }
-
-            if (!ok) {
-                QVariantList a;
-                for (auto &pair : enumValues) {
-                    a.append(pair.first);
-                }
-                errors.addError<EnumConstraintViolationError>(path, ret, a);
-                return {};
-            }
-            return ret;
-        }
-
-        std::array<QPair<K, T>, N> enumValues;
-    };
-
-    template <typename T, typename C>
-    QList<T> fromJsonArrayHelper(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QList<T> list;
-        auto array = json.toArray();
-        if (auto actualType = getDataType(array); (options & Serializer::CheckError) && actualType != InvalidDataTypeError::Array) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Array});
-            return {};
-        }
-        for (auto it = array.begin(); it != array.end(); ++it) {
-            auto index = std::distance(array.begin(), it);
-            auto v = C::template fromJson<T>(*it, errors, options, path + "[" + QString::number(index) + "]");
-            FAIL_FAST_RETURN(list);
-            list.append(v);
-        }
-        return list;
-    }
-
-    template <typename C = void>
-    inline QList<int> fromJsonArrayHelper(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QList<int> list;
-        auto array = json.toArray();
-        if (auto actualType = getDataType(array); (options & Serializer::CheckError) && actualType != InvalidDataTypeError::Array) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Array});
-            return {};
-        }
-        for (auto it = array.begin(); it != array.end(); ++it) {
-            auto index = std::distance(array.begin(), it);
-            auto v = fromJsonIntHelper(*it, errors, options, path + "[" + QString::number(index) + "]");
-            FAIL_FAST_RETURN(list);
-            list.append(v);
-        }
-        return list;
-    }
-
-    inline QJsonObject fromJsonObjectHelper(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        if (!(options & Serializer::CheckError)) {
-            return value.toObject();
-        }
-        if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Object) {
-            errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Object});
-        }
-        return value.toObject();
-    }
-
-    template <size_t N>
-    struct fromJsonObjectHelperWithPropertyCheck {
-        fromJsonObjectHelperWithPropertyCheck(std::array<const char *, N> &&properties) : properties(properties) {
-        }
-
-        QJsonObject operator()(const QJsonValue &value, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            if (!(options & Serializer::CheckError)) {
-                return value.toObject();
-            }
-            if (auto actualType = getDataType(value); actualType != InvalidDataTypeError::Object) {
-                errors.addError<InvalidDataTypeError>(path, actualType, QList{InvalidDataTypeError::Object});
-                return {};
-            }
-            auto obj = value.toObject();
-            QStringList missingProperties;
-            for (auto &property : properties) {
-                if (!obj.contains(property)) {
-                    missingProperties.append(property);
-                }
-            }
-            if (!missingProperties.isEmpty()) {
-                errors.addError<MissingPropertyError>(path, missingProperties);
-            }
-            if (!(options & Serializer::TolerateRedundantProperty) && obj.count() + missingProperties.size() > properties.size()) {
-                QStringList redundantProperties;
-                for (auto it = obj.begin(); it != obj.end(); ++it) {
-                    if (!std::ranges::any_of(properties, [it](const auto &property) {
-                        return it.key() == property;
-                    })) {
-                        redundantProperties.append(it.key());
-                    }
-                }
-                errors.addError<RedundantPropertyError>(path, redundantProperties);
-            }
-            return obj;
-        }
-
-        std::array<const char *, N> properties;
-    };
-
-}
-
-#endif //OPENDSPX_SERIALIZATION_CONVERTERHELPER_P_H
diff --git a/src/serializer/converterhelpertojson_p.h b/src/serializer/converterhelpertojson_p.h
deleted file mode 100644
index e4f49f1..0000000
--- a/src/serializer/converterhelpertojson_p.h
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef OPENDSPX_SERIALIZER_CONVERTERHELPERTOJSON_P_H
-#define OPENDSPX_SERIALIZER_CONVERTERHELPERTOJSON_P_H
-
-#include <QJsonArray>
-#include <QJsonValue>
-
-#include <opendspxserializer/serializer.h>
-#include <opendspxserializer/serializationerror.h>
-
-#ifndef FAIL_FAST_RETURN
-#define FAIL_FAST_RETURN(ret) \
-    do { \
-        if ((options & Serializer::FailFast) && errors.containsError()) { \
-            return ret; \
-        } \
-    } while (false)
-#endif
-
-#define TO_JSON_PROPERTY_FAIL_FAST(entity, property, parseFunc, ret) \
-    do { \
-        FAIL_FAST_RETURN(ret); \
-        auto v = parseFunc(entity property, errors, options, path + "."#property); \
-        FAIL_FAST_RETURN(ret); \
-        object.insert(#property, v); \
-    } while (false)
-
-namespace QDspx {
-
-    template <typename T>
-    QJsonValue toJsonTrivial(T v, SerializationErrorList &, Serializer::Option, const QString &) {
-        return v;
-    }
-
-    struct toJsonNumberHelperWithConstraint {
-        toJsonNumberHelperWithConstraint(double minimum, double maximum = std::numeric_limits<double>::lowest()) : minimum(minimum), maximum(maximum) {
-        }
-
-        template <typename T>
-        QJsonValue operator()(T v, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            if (!(options & Serializer::CheckError)) {
-                return v;
-            }
-            if (v < minimum || (maximum >= minimum && v > maximum)) {
-                auto maxVar = maximum >= minimum ? maximum : QVariant();
-                errors.addError<RangeConstraintViolationError>(path, v, minimum, maxVar);
-            }
-            return v;
-        }
-
-        double maximum;
-        double minimum;
-    };
-
-    template <typename K, typename T, size_t N>
-    struct toJsonEnumHelper {
-        toJsonEnumHelper(const std::array<std::pair<K, T>, N> &enumValues) : enumValues(enumValues) {
-        }
-
-        QJsonValue operator()(T value, SerializationErrorList &errors, Serializer::Option options, const QString &path) const {
-            auto it = std::ranges::find_if(enumValues, [value](const auto &pair) {
-                return pair.second == value;
-            });
-            if (it == enumValues.end()) {
-                if (!(options & Serializer::CheckError)) {
-                    return {};
-                }
-                QVariantList a;
-                for (auto &pair : enumValues) {
-                    a.append(pair.second);
-                }
-                errors.addError<EnumConstraintViolationError>(path, value, a);
-                return {};
-            }
-            return it->first;
-        }
-
-        std::array<std::pair<K, T>, N> enumValues;
-    };
-
-    template <typename T, typename C>
-    QJsonArray toJsonArrayHelper(const QList<T> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonArray array;
-        for (auto it = entity.begin(); it != entity.end(); ++it) {
-            auto index = std::distance(entity.begin(), it);
-            array.append(C::template toJson<T>(*it, errors, options, path + "[" + QString::number(index) + "]"));
-        }
-        return array;
-    }
-
-    template <typename C = void>
-    QJsonArray toJsonArrayHelper(const QList<int> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonArray array;
-        for (auto it = entity.begin(); it != entity.end(); ++it) {
-            array.append(*it);
-        }
-        return array;
-    }
-
-}
-
-#endif //OPENDSPX_SERIALIZER_CONVERTERHELPERTOJSON_P_H
diff --git a/src/serializer/jsonconverterv1.cpp b/src/serializer/jsonconverterv1.cpp
index 338231d..9f8a83e 100644
--- a/src/serializer/jsonconverterv1.cpp
+++ b/src/serializer/jsonconverterv1.cpp
@@ -1,763 +1 @@
 #include "jsonconverterv1.h"
-
-#include <QJsonObject>
-#include <QJsonArray>
-
-#include <opendspx/model.h>
-#include <opendspxserializer/serializationerror.h>
-
-#include "converterhelperfromjson_p.h"
-#include "converterhelpertojson_p.h"
-
-namespace QDspx{
-
-    constexpr auto INTERP_ENUM_DEFS = std::array{
-        std::pair{"none", AnchorNode::None},
-        std::pair{"linear", AnchorNode::Linear},
-        std::pair{"hermite", AnchorNode::Hermite}
-    };
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<AnchorNode>(const AnchorNode &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., x, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., y, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., interp, toJsonEnumHelper(INTERP_ENUM_DEFS), object);
-        return object;
-    }
-
-    template <>
-    AnchorNode JsonConverterV1::fromJson<AnchorNode>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"x", "y", "interp"}), {});
-        AnchorNode node;
-        FROM_JSON_PROPERTY_FAIL_FAST(node., x, fromJsonIntHelperWithConstraint(0), node);
-        FROM_JSON_PROPERTY_FAIL_FAST(node., y, fromJsonIntHelper, node);
-        FROM_JSON_PROPERTY_FAIL_FAST(node., interp, fromJsonEnumHelper(INTERP_ENUM_DEFS), node);
-        return node;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<AudioClip>>(const AudioClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        object.insert("type", "audio");
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, name, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, control, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, time, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, path, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, workspace, toJson, object);
-        return object;
-    }
-
-    template <>
-    AudioClipRef JsonConverterV1::fromJson<QSharedPointer<AudioClip>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"type", "name", "control", "time", "path", "workspace"}), {});
-        auto clip = QSharedPointer<AudioClip>::create();
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, name, fromJsonStringHelper, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, control, fromJson<BusControl>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, time, fromJson<ClipTime>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, path, fromJsonStringHelper, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, workspace, fromJson<Workspace>, clip);
-        return clip;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<BusControl>(const BusControl &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., gain, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pan, toJsonNumberHelperWithConstraint(-1, 1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., mute, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    BusControl JsonConverterV1::fromJson<BusControl>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"gain", "pan", "mute"}), {});
-        BusControl control;
-        FROM_JSON_PROPERTY_FAIL_FAST(control., gain, fromJsonDoubleHelper, control);
-        FROM_JSON_PROPERTY_FAIL_FAST(control., pan, fromJsonDoubleHelperWithConstraint(-1, 1), control);
-        FROM_JSON_PROPERTY_FAIL_FAST(control., mute, fromJsonBoolHelper, control);
-        return control;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<ClipTime>(const ClipTime &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., start, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., length, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., clipStart, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., clipLen, toJsonNumberHelperWithConstraint(0), object);
-        return object;
-    }
-
-    template <>
-    ClipTime JsonConverterV1::fromJson<ClipTime>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"start", "length", "clipStart", "clipLen"}), {});
-        ClipTime time;
-        FROM_JSON_PROPERTY_FAIL_FAST(time., start, fromJsonIntHelper, time);
-        FROM_JSON_PROPERTY_FAIL_FAST(time., length, fromJsonIntHelperWithConstraint(0), time);
-        FROM_JSON_PROPERTY_FAIL_FAST(time., clipStart, fromJsonIntHelperWithConstraint(0), time);
-        FROM_JSON_PROPERTY_FAIL_FAST(time., clipLen, fromJsonIntHelperWithConstraint(0), time);
-        return time;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<ControlPoint>(const ControlPoint &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., x, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., y, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    ControlPoint JsonConverterV1::fromJson<ControlPoint>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"x", "y"}), {});
-        ControlPoint point;
-        FROM_JSON_PROPERTY_FAIL_FAST(point., x, fromJsonDoubleHelper, point);
-        FROM_JSON_PROPERTY_FAIL_FAST(point., y, fromJsonDoubleHelper, point);
-        return point;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<Clip>>(const ClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        switch (entity->type) {
-            case Clip::Type::Audio:
-                return toJson<QSharedPointer<AudioClip>>(entity.staticCast<AudioClip>(), errors, options, path);
-            case Clip::Type::Singing:
-                return toJson<QSharedPointer<SingingClip>>(entity.staticCast<SingingClip>(), errors, options, path);
-            default: {
-                Q_UNREACHABLE();
-            }
-        }
-    }
-
-    template <>
-    ClipRef JsonConverterV1::fromJson<QSharedPointer<Clip>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelper, {});
-        auto type = object.value("type").toString();
-        if (type == "audio") {
-            return fromJson<QSharedPointer<AudioClip>>(json, errors, options, path);
-        }
-        if (type == "singing") {
-            return fromJson<QSharedPointer<SingingClip>>(json, errors, options, path);
-        }
-        errors.addError<InvalidObjectTypeError>(path, type, QStringList{"audio", "singing"});
-        return {};
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Content>(const Content &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., global, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., master, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., timeline, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., tracks, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., workspace, toJson, object);
-        return object;
-    }
-
-    template <>
-    Content JsonConverterV1::fromJson<Content>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"global", "master", "timeline", "tracks", "workspace"}), {});
-        Content content;
-        FROM_JSON_PROPERTY_FAIL_FAST(content., global, fromJson<Global>, content);
-        FROM_JSON_PROPERTY_FAIL_FAST(content., master, fromJson<Master>, content);
-        FROM_JSON_PROPERTY_FAIL_FAST(content., timeline, fromJson<Timeline>, content);
-        FROM_JSON_PROPERTY_FAIL_FAST(content., tracks, fromJson<QList<Track>>, content);
-        FROM_JSON_PROPERTY_FAIL_FAST(content., workspace, fromJson<Workspace>, content);
-        return content;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Global>(const Global &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., author, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., name, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., centShift, toJsonNumberHelperWithConstraint(-50, 50), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., editorId, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., editorName, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    Global JsonConverterV1::fromJson<Global>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"author", "name", "centShift", "editorId", "editorName"}), {});
-        Global global;
-        FROM_JSON_PROPERTY_FAIL_FAST(global., author, fromJsonStringHelper, global);
-        FROM_JSON_PROPERTY_FAIL_FAST(global., name, fromJsonStringHelper, global);
-        FROM_JSON_PROPERTY_FAIL_FAST(global., centShift, fromJsonIntHelperWithConstraint(-50, 50), global);
-        FROM_JSON_PROPERTY_FAIL_FAST(global., editorId, fromJsonStringHelper, global);
-        FROM_JSON_PROPERTY_FAIL_FAST(global., editorName, fromJsonStringHelper, global);
-        return global;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Label>(const Label &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pos, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., text, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    Label JsonConverterV1::fromJson<Label>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"pos", "text"}), {});
-        Label label;
-        FROM_JSON_PROPERTY_FAIL_FAST(label., pos, fromJsonIntHelperWithConstraint(0), label);
-        FROM_JSON_PROPERTY_FAIL_FAST(label., text, fromJsonStringHelper, label);
-        return label;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<Label>>(const QList<Label> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<Label, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<Label> JsonConverterV1::fromJson<QList<Label>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<Label, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Master>(const Master &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., control, toJson, object);
-        return object;
-    }
-
-    template <>
-    Master JsonConverterV1::fromJson<Master>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"control"}), {});
-        Master master;
-        FROM_JSON_PROPERTY_FAIL_FAST(master., control, fromJson<BusControl>, master);
-        return master;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Model>(const Model &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        object.insert("version", "1.0.0");
-        TO_JSON_PROPERTY_FAIL_FAST(entity., content, toJson, object);
-        return object;
-    }
-
-    template <>
-    Model JsonConverterV1::fromJson<Model>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"version", "content"}), {});
-        Model model;
-        model.version = Model::V1;
-        FROM_JSON_PROPERTY_FAIL_FAST(model., content, fromJson<Content>, model);
-        return model;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Note>(const Note &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pos, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., length, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., keyNum, toJsonNumberHelperWithConstraint(0, 127), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., centShift, toJsonNumberHelperWithConstraint(-50, 50), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., language, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., lyric, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pronunciation, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., phonemes, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., vibrato, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., workspace, toJson, object);
-        return object;
-    }
-
-    template <>
-    Note JsonConverterV1::fromJson<Note>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"pos", "length", "keyNum", "centShift", "language", "lyric", "pronunciation", "phonemes", "vibrato", "workspace"}), {});
-        Note note;
-        FROM_JSON_PROPERTY_FAIL_FAST(note., pos, fromJsonIntHelperWithConstraint(0), note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., length, fromJsonIntHelperWithConstraint(0), note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., keyNum, fromJsonIntHelperWithConstraint(0, 127), note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., centShift, fromJsonIntHelperWithConstraint(-50, 50), note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., language, fromJsonStringHelper, note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., lyric, fromJsonStringHelper, note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., pronunciation, fromJson<Pronunciation>, note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., phonemes, fromJson<Phonemes>, note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., vibrato, fromJson<Vibrato>, note);
-        FROM_JSON_PROPERTY_FAIL_FAST(note., workspace, fromJson<Workspace>, note);
-        return note;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<Note>>(const QList<Note> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<Note, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<Note> JsonConverterV1::fromJson<QList<Note>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<Note, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Param>(const Param &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., original, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., transform, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., edited, toJson, object);
-        return object;
-    }
-
-    template <>
-    Param JsonConverterV1::fromJson<Param>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"original", "transform", "edited"}), {});
-        Param param;
-        FROM_JSON_PROPERTY_FAIL_FAST(param., original, fromJson<QList<ParamCurveRef>>, param);
-        FROM_JSON_PROPERTY_FAIL_FAST(param., transform, fromJson<QList<ParamCurveRef>>, param);
-        FROM_JSON_PROPERTY_FAIL_FAST(param., edited, fromJson<QList<ParamCurveRef>>, param);
-        return param;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<ParamCurve>>(const ParamCurveRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        switch (entity->type) {
-            case ParamCurve::Anchor:
-                return toJson<QSharedPointer<ParamCurveAnchor>>(entity.staticCast<ParamCurveAnchor>(), errors, options, path);
-            case ParamCurve::Free:
-                return toJson<QSharedPointer<ParamCurveFree>>(entity.staticCast<ParamCurveFree>(), errors, options, path);
-            default: {
-                Q_UNREACHABLE();
-            }
-        }
-    }
-
-    template <>
-    ParamCurveRef JsonConverterV1::fromJson<QSharedPointer<ParamCurve>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelper, {});
-        auto type = object.value("type").toString();
-        if (type == "anchor") {
-            return fromJson<QSharedPointer<ParamCurveAnchor>>(json, errors, options, path);
-        }
-        if (type == "free") {
-            return fromJson<QSharedPointer<ParamCurveFree>>(json, errors, options, path);
-        }
-        errors.addError<InvalidObjectTypeError>(path, type, QStringList{"anchor", "free"});
-        return {};
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<ParamCurveAnchor>>(const ParamCurveAnchorRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        object.insert("type", "anchor");
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, start, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, nodes, toJson, object);
-        return object;
-    }
-
-    template <>
-    ParamCurveAnchorRef JsonConverterV1::fromJson<QSharedPointer<ParamCurveAnchor>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"type", "start", "nodes"}), {});
-        auto curve = QSharedPointer<ParamCurveAnchor>::create();
-        FROM_JSON_PROPERTY_FAIL_FAST(curve->, start, fromJsonIntHelper, curve);
-        FROM_JSON_PROPERTY_FAIL_FAST(curve->, nodes, fromJson<QList<AnchorNode>>, curve);
-        return curve;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<ParamCurveFree>>(const ParamCurveFreeRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        object.insert("type", "free");
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, start, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, step, toJsonNumberHelperWithConstraint(5, 5), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, values, toJsonArrayHelper, object);
-        return object;
-    }
-
-    template <>
-    ParamCurveFreeRef JsonConverterV1::fromJson<QSharedPointer<ParamCurveFree>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"type", "start", "step", "values"}), {});
-        auto curve = QSharedPointer<ParamCurveFree>::create();
-        FROM_JSON_PROPERTY_FAIL_FAST(curve->, start, fromJsonIntHelper, curve);
-        FROM_JSON_PROPERTY_FAIL_FAST(curve->, step, fromJsonIntHelperWithConstraint(5, 5), curve);
-        FROM_JSON_PROPERTY_FAIL_FAST(curve->, values, fromJsonArrayHelper<int>, curve);
-        return curve;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<ParamCurveRef>>(const QList<ParamCurveRef> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<ParamCurveRef, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<ParamCurveRef> JsonConverterV1::fromJson<QList<ParamCurveRef>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<ParamCurveRef, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Params>(const Params &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        for (const auto &[key, value] : entity.asKeyValueRange()) {
-            object.insert(key, toJson<Param>(value, errors, options, path + "." + key));
-        }
-        return object;
-    }
-
-    template <>
-    Params JsonConverterV1::fromJson<Params>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelper, {});
-        Params params;
-        for (auto it = object.begin(); it != object.end(); ++it) {
-            params.insert(it.key(), fromJson<Param>(it.value(), errors, options, path + "." + it.key()));
-        }
-        return params;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Phoneme>(const Phoneme &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., language, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., token, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., start, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., onset, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    Phoneme JsonConverterV1::fromJson<Phoneme>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"language", "token", "start", "onset"}), {});
-        Phoneme phoneme;
-        FROM_JSON_PROPERTY_FAIL_FAST(phoneme., language, fromJsonStringHelper, phoneme);
-        FROM_JSON_PROPERTY_FAIL_FAST(phoneme., token, fromJsonStringHelper, phoneme);
-        FROM_JSON_PROPERTY_FAIL_FAST(phoneme., start, fromJsonIntHelper, phoneme);
-        FROM_JSON_PROPERTY_FAIL_FAST(phoneme., onset, fromJsonBoolHelper, phoneme);
-        return phoneme;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<Phoneme>>(const QList<Phoneme> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<Phoneme, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<Phoneme> JsonConverterV1::fromJson<QList<Phoneme>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<Phoneme, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Phonemes>(const Phonemes &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., original, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., edited, toJson, object);
-        return object;
-    }
-
-    template <>
-    Phonemes JsonConverterV1::fromJson<Phonemes>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"original", "edited"}), {});
-        Phonemes phonemes;
-        FROM_JSON_PROPERTY_FAIL_FAST(phonemes., original, fromJson<QList<Phoneme>>, phonemes);
-        FROM_JSON_PROPERTY_FAIL_FAST(phonemes., edited, fromJson<QList<Phoneme>>, phonemes);
-        return phonemes;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Pronunciation>(const Pronunciation &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., original, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., edited, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    Pronunciation JsonConverterV1::fromJson<Pronunciation>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"original", "edited"}), {});
-        Pronunciation pronunciation;
-        FROM_JSON_PROPERTY_FAIL_FAST(pronunciation., original, fromJsonStringHelper, pronunciation);
-        FROM_JSON_PROPERTY_FAIL_FAST(pronunciation., edited, fromJsonStringHelper, pronunciation);
-        return pronunciation;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QSharedPointer<SingingClip>>(const SingingClipRef &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        object.insert("type", "singing");
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, name, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, control, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, time, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, notes, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, params, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, sources, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity->, workspace, toJson, object);
-        return object;
-    }
-
-    template <>
-    SingingClipRef JsonConverterV1::fromJson<QSharedPointer<SingingClip>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"type", "name", "control", "time", "notes", "params", "sources", "workspace"}), {});
-        auto clip = QSharedPointer<SingingClip>::create();
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, name, fromJsonStringHelper, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, control, fromJson<BusControl>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, time, fromJson<ClipTime>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, notes, fromJson<QList<Note>>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, params, fromJson<Params>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, sources, fromJson<Sources>, clip);
-        FROM_JSON_PROPERTY_FAIL_FAST(clip->, workspace, fromJson<Workspace>, clip);
-        return clip;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Sources>(const Sources &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        for (const auto &[key, value] : entity.asKeyValueRange()) {
-            object.insert(key, value);
-        }
-        return object;
-    }
-
-    template <>
-    Sources JsonConverterV1::fromJson<Sources>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelper, {});
-        Sources sources;
-        for (auto it = object.begin(); it != object.end(); ++it) {
-            QJsonObject o = fromJsonObjectHelper(it.value(), errors, options, path + "." + it.key());
-            FAIL_FAST_RETURN(sources);
-            sources.insert(it.key(), o);
-        }
-        return sources;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Tempo>(const Tempo &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pos, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., value, toJsonNumberHelperWithConstraint(10, 1000), object);
-        return object;
-    }
-
-    template <>
-    Tempo JsonConverterV1::fromJson<Tempo>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"pos", "value"}), {});
-        Tempo tempo;
-        FROM_JSON_PROPERTY_FAIL_FAST(tempo., pos, fromJsonIntHelperWithConstraint(0), tempo);
-        FROM_JSON_PROPERTY_FAIL_FAST(tempo., value, fromJsonDoubleHelperWithConstraint(10, 1000), tempo);
-        return tempo;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<Tempo>>(const QList<Tempo> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<Tempo, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<Tempo> JsonConverterV1::fromJson<QList<Tempo>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<Tempo, JsonConverterV1>(json, errors, options, path);
-    }
-
-    constexpr auto DENOMINATOR_ENUM_DEFS = std::array{
-        std::pair{1, 1},
-        std::pair{2, 2},
-        std::pair{4, 4},
-        std::pair{8, 8},
-        std::pair{16, 16},
-        std::pair{32, 32},
-        std::pair{64, 64},
-        std::pair{128, 128}
-    };
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<TimeSignature>(const TimeSignature &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., index, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., numerator, toJsonNumberHelperWithConstraint(1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., denominator, toJsonEnumHelper(DENOMINATOR_ENUM_DEFS), object);
-        return object;
-    }
-
-    template <>
-    TimeSignature JsonConverterV1::fromJson<TimeSignature>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"index", "numerator", "denominator"}), {});
-        TimeSignature sig;
-        FROM_JSON_PROPERTY_FAIL_FAST(sig., index, fromJsonIntHelperWithConstraint(0), sig);
-        FROM_JSON_PROPERTY_FAIL_FAST(sig., numerator, fromJsonIntHelperWithConstraint(1), sig);
-        FROM_JSON_PROPERTY_FAIL_FAST(sig., denominator, fromJsonEnumHelper(DENOMINATOR_ENUM_DEFS), sig);
-        return sig;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<TimeSignature>>(const QList<TimeSignature> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<TimeSignature, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<TimeSignature> JsonConverterV1::fromJson<QList<TimeSignature>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<TimeSignature, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Timeline>(const Timeline &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., labels, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., tempos, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., timeSignatures, toJson, object);
-        return object;
-    }
-
-    template <>
-    Timeline JsonConverterV1::fromJson<Timeline>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"labels", "tempos", "timeSignatures"}), {});
-        Timeline timeline;
-        FROM_JSON_PROPERTY_FAIL_FAST(timeline., labels, fromJson<QList<Label>>, timeline);
-        FROM_JSON_PROPERTY_FAIL_FAST(timeline., tempos, fromJson<QList<Tempo>>, timeline);
-        FROM_JSON_PROPERTY_FAIL_FAST(timeline., timeSignatures, fromJson<QList<TimeSignature>>, timeline);
-        return timeline;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Track>(const Track &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., name, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., control, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., clips, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., workspace, toJson, object);
-        return object;
-    }
-
-    template <>
-    Track JsonConverterV1::fromJson<Track>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"name", "control", "clips", "workspace"}), {});
-        Track track;
-        FROM_JSON_PROPERTY_FAIL_FAST(track., name, fromJsonStringHelper, track);
-        FROM_JSON_PROPERTY_FAIL_FAST(track., control, fromJson<TrackControl>, track);
-        FROM_JSON_PROPERTY_FAIL_FAST(track., clips, fromJson<QList<ClipRef>>, track);
-        FROM_JSON_PROPERTY_FAIL_FAST(track., workspace, fromJson<Workspace>, track);
-        return track;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<Track>>(const QList<Track> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<Track, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<Track> JsonConverterV1::fromJson<QList<Track>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<Track, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<TrackControl>(const TrackControl &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., gain, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., pan, toJsonNumberHelperWithConstraint(-1, 1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., mute, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., solo, toJsonTrivial, object);
-        return object;
-    }
-
-    template <>
-    TrackControl JsonConverterV1::fromJson<TrackControl>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"gain", "pan", "mute", "solo"}), {});
-        TrackControl control;
-        FROM_JSON_PROPERTY_FAIL_FAST(control., gain, fromJsonDoubleHelper, control);
-        FROM_JSON_PROPERTY_FAIL_FAST(control., pan, fromJsonDoubleHelperWithConstraint(-1, 1), control);
-        FROM_JSON_PROPERTY_FAIL_FAST(control., mute, fromJsonBoolHelper, control);
-        FROM_JSON_PROPERTY_FAIL_FAST(control., solo, fromJsonBoolHelper, control);
-        return control;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<Vibrato>(const Vibrato &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., start, toJsonNumberHelperWithConstraint(0, 1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., end, toJsonNumberHelperWithConstraint(0, 1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., amp, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., freq, toJsonNumberHelperWithConstraint(0), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., phase, toJsonNumberHelperWithConstraint(0, 1), object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., offset, toJsonTrivial, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., points, toJson, object);
-        return object;
-    }
-
-    template <>
-    Vibrato JsonConverterV1::fromJson<Vibrato>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"start", "end", "amp", "freq", "phase", "offset", "points"}), {});
-        Vibrato vibrato;
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., start, fromJsonDoubleHelperWithConstraint(0, 1), vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., end, fromJsonDoubleHelperWithConstraint(0, 1), vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., amp, fromJsonIntHelperWithConstraint(0), vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., freq, fromJsonDoubleHelperWithConstraint(0), vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., phase, fromJsonDoubleHelperWithConstraint(0, 1), vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., offset, fromJsonIntHelper, vibrato);
-        FROM_JSON_PROPERTY_FAIL_FAST(vibrato., points, fromJson<VibratoPoints>, vibrato);
-        return vibrato;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<VibratoPoints>(const VibratoPoints &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        TO_JSON_PROPERTY_FAIL_FAST(entity., amp, toJson, object);
-        TO_JSON_PROPERTY_FAIL_FAST(entity., freq, toJson, object);
-        return object;
-    }
-
-    template <>
-    VibratoPoints JsonConverterV1::fromJson<VibratoPoints>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        QJsonObject object;
-        FROM_JSON_FAIL_FAST(object, json, fromJsonObjectHelperWithPropertyCheck(std::array{"amp", "freq"}), {});
-        VibratoPoints points;
-        FROM_JSON_PROPERTY_FAIL_FAST(points., amp, fromJson<QList<ControlPoint>>, points);
-        FROM_JSON_PROPERTY_FAIL_FAST(points., freq, fromJson<QList<ControlPoint>>, points);
-        return points;
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<ControlPoint>>(const QList<ControlPoint> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<ControlPoint, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<ControlPoint> JsonConverterV1::fromJson<QList<ControlPoint>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<ControlPoint, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<AnchorNode>>(const QList<AnchorNode> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<AnchorNode, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<AnchorNode> JsonConverterV1::fromJson<QList<AnchorNode>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<AnchorNode, JsonConverterV1>(json, errors, options, path);
-    }
-
-    template <>
-    QJsonValue JsonConverterV1::toJson<QList<ClipRef>>(const QList<ClipRef> &entity, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return toJsonArrayHelper<ClipRef, JsonConverterV1>(entity, errors, options, path);
-    }
-
-    template <>
-    QList<ClipRef> JsonConverterV1::fromJson<QList<ClipRef>>(const QJsonValue &json, SerializationErrorList &errors, Serializer::Option options, const QString &path) {
-        return fromJsonArrayHelper<ClipRef, JsonConverterV1>(json, errors, options, path);
-    }
-
-}
diff --git a/src/serializer/serializer.cpp b/src/serializer/serializer.cpp
index 6d14098..218c1d3 100644
--- a/src/serializer/serializer.cpp
+++ b/src/serializer/serializer.cpp
@@ -1,57 +1,155 @@
 #include "serializer.h"
 
-#include <QJsonDocument>
+#include "zstdstreambuf_p.h"
+
+#include <array>
+#include <cassert>
+#include <ios>
+#include <memory>
 
 #include <opendspx/model.h>
 
 #include <opendspxserializer/jsonconverterv1.h>
 #include <opendspxserializer/serializationerror.h>
 
-namespace QDspx {
+namespace opendspx {
+
+    namespace {
+
+        bool isZstdHeader(std::istream &in) {
+            using traits_type = std::streambuf::traits_type;
+
+            auto *buf = in.rdbuf();
+            std::array<unsigned char, 4> header{};
+
+            const auto first = buf->sgetc();
+            if (traits_type::eq_int_type(first, traits_type::eof())) {
+                return false;
+            }
+            header[0] = static_cast<unsigned char>(traits_type::to_char_type(first));
+
+            int count = 1;
+            while (count < 4) {
+                const auto ch = buf->snextc();
+                if (traits_type::eq_int_type(ch, traits_type::eof())) {
+                    break;
+                }
+                header[count] = static_cast<unsigned char>(traits_type::to_char_type(ch));
+                ++count;
+            }
+
+            for (int i = 1; i < count; ++i) {
+                if (buf->sungetc() == traits_type::eof()) {
+                    return false;
+                }
+            }
 
-    QString Serializer::versionToText(Model::Version version) {
+            if (count < 4) {
+                return false;
+            }
+            return header[0] == 0x28 && header[1] == 0xB5 && header[2] == 0x2F && header[3] == 0xFD;
+        }
+
+    }
+
+    std::string Serializer::versionToText(Model::Version version) {
         switch (version) {
-            case Model::V1:
+            case Model::Version::V1:
                 return "1.0.0";
             default:
                 return {};
         }
     }
 
-    Model::Version Serializer::versionFromText(const QString &text, bool *ok) {
+    Model::Version Serializer::versionFromText(const std::string &text, bool *ok) {
         if (ok)
             *ok = true;
         if (text == "1.0.0") {
-            return Model::V1;
+            return Model::Version::V1;
         }
         if (ok)
             *ok = false;
         return {};
     }
 
-    QByteArray Serializer::serialize(const Model &model, SerializationErrorList &errors, Option options) {
+    void Serializer::serialize(std::ostream &out, const Model &model, SerializationErrorList &errors, Option options, bool compress) {
+        nlohmann::json doc;
         switch (model.version) {
-            case Model::V1:
-                return JsonConverterV1::toJson(model, errors, options).toJson(QJsonDocument::Compact);
+            case Model::Version::V1:
+                doc = JsonConverterV1::toJson(model, errors, options);
+                break;
             default: {
-                errors.addError<UnrecognizedVersionError>(model.version);
-                return {};
+                errors.addError<UnrecognizedVersionError>(static_cast<int>(model.version));
+                return;
+            }
+        }
+
+        std::ostream *jsonOutput = &out;
+        std::unique_ptr<ZstdStreamBuf> zstdBuf;
+        std::unique_ptr<std::ostream> zstdOut;
+
+        if (compress) {
+            zstdBuf = std::make_unique<ZstdStreamBuf>(out);
+            if (!zstdBuf->good()) {
+                errors.addError<CompressionFailureError>(zstdBuf->errorMessage());
+                return;
+            }
+
+            zstdOut = std::make_unique<std::ostream>(zstdBuf.get());
+            jsonOutput = zstdOut.get();
+        }
+
+        // Here we have to use private api to specify error_handler
+        nlohmann::detail::serializer<nlohmann::json> s(nlohmann::detail::output_adapter<char>(*jsonOutput), ' ', nlohmann::detail::error_handler_t::replace);
+        s.dump(doc, false, false, 0);
+
+        if (compress) {
+            zstdOut->flush();
+
+            if (!zstdBuf->finish()) {
+                errors.addError<CompressionFailureError>(zstdBuf->errorMessage());
             }
         }
     }
 
-    Model Serializer::deserialize(const QByteArray &data, SerializationErrorList &errors, Option options) {
-        QJsonParseError jsonParseError;
-        auto doc = QJsonDocument::fromJson(data, &jsonParseError);
-        if (jsonParseError.error != QJsonParseError::NoError) {
-            errors.addError<JsonParseFailureError>(jsonParseError);
+    Model Serializer::deserialize(std::istream &in, SerializationErrorList &errors, Option options) {
+        nlohmann::json doc;
+
+        std::istream *jsonInput = &in;
+        std::unique_ptr<ZstdStreamBuf> zstdBuf;
+        std::unique_ptr<std::istream> zstdIn;
+
+        if (isZstdHeader(in)) {
+            zstdBuf = std::make_unique<ZstdStreamBuf>(in);
+            if (!zstdBuf->good()) {
+                errors.addError<CompressionFailureError>(zstdBuf->errorMessage());
+                return {};
+            }
+            zstdIn = std::make_unique<std::istream>(zstdBuf.get());
+            jsonInput = zstdIn.get();
+        }
+
+        try {
+            doc = nlohmann::json::parse(*jsonInput, nullptr);
+        } catch (const nlohmann::json::parse_error &e) {
+            if (zstdBuf && zstdBuf->hasError()) {
+                errors.addError<CompressionFailureError>(zstdBuf->errorMessage());
+                return {};
+            }
+            errors.addError<JsonParseFailureError>(e.id, e.byte, e.what());
             return {};
         }
-        if (!doc.isObject()) {
+        if (!doc.is_object()) {
             errors.addError<JsonRootIsNotObjectError>();
         }
-        auto obj = doc.object();
-        auto versionText = obj.value("version").toString();
+        auto obj = std::move(doc);
+        std::string versionText;
+        try {
+            versionText = obj.at("version").get<std::string>();
+        } catch (const nlohmann::json::exception &e) {
+            errors.addError<UnrecognizedVersionError>(std::string{});
+            return {};
+        }
         bool ok;
         auto version = versionFromText(versionText, &ok);
         if (!ok) {
@@ -59,10 +157,11 @@ namespace QDspx {
             return {};
         }
         switch (version) {
-            case Model::V1:
+            case Model::Version::V1:
                 return JsonConverterV1::fromJson<Model>(obj, errors, options);
         }
-        Q_UNREACHABLE();
+        assert(false && "Unrecognized version");
+        return {};
     }
 
 }
diff --git a/src/serializer/zstdstreambuf.cpp b/src/serializer/zstdstreambuf.cpp
new file mode 100644
index 0000000..d44b762
--- /dev/null
+++ b/src/serializer/zstdstreambuf.cpp
@@ -0,0 +1,223 @@
+#include "zstdstreambuf_p.h"
+
+#include <algorithm>
+
+namespace opendspx {
+
+    ZstdStreamBuf::ZstdStreamBuf(std::ostream &out, int compressionLevel)
+        : m_mode(Mode::Compress), m_out(&out) {
+        m_cstream = ZSTD_createCStream();
+        if (!m_cstream) {
+            setError("Failed to create zstd compression stream");
+            return;
+        }
+        const auto initRet = ZSTD_initCStream(m_cstream, compressionLevel);
+        if (ZSTD_isError(initRet)) {
+            setError(ZSTD_getErrorName(initRet));
+            return;
+        }
+        setp(m_inBuffer.data(), m_inBuffer.data() + m_inBuffer.size());
+    }
+
+    ZstdStreamBuf::ZstdStreamBuf(std::istream &in)
+        : m_mode(Mode::Decompress), m_in(&in), m_decompressRet(1) {
+        m_dstream = ZSTD_createDStream();
+        if (!m_dstream) {
+            setError("Failed to create zstd decompression stream");
+            return;
+        }
+        const auto initRet = ZSTD_initDStream(m_dstream);
+        if (ZSTD_isError(initRet)) {
+            setError(ZSTD_getErrorName(initRet));
+            return;
+        }
+        setg(m_outBuffer.data(), m_outBuffer.data(), m_outBuffer.data());
+    }
+
+    ZstdStreamBuf::~ZstdStreamBuf() {
+        if (m_mode == Mode::Compress && m_cstream && !m_finished && !hasError()) {
+            finish();
+        }
+        if (m_cstream) {
+            ZSTD_freeCStream(m_cstream);
+        }
+        if (m_dstream) {
+            ZSTD_freeDStream(m_dstream);
+        }
+    }
+
+    bool ZstdStreamBuf::good() const {
+        return !hasError();
+    }
+
+    bool ZstdStreamBuf::hasError() const {
+        return !m_errorMessage.empty();
+    }
+
+    const std::string &ZstdStreamBuf::errorMessage() const {
+        return m_errorMessage;
+    }
+
+    bool ZstdStreamBuf::finish() {
+        if (m_mode == Mode::Decompress) {
+            m_finished = true;
+            return !hasError();
+        }
+        if (m_finished) {
+            return !hasError();
+        }
+        if (!compressBuffered()) {
+            return false;
+        }
+        if (!finishCompression()) {
+            return false;
+        }
+        m_finished = true;
+        return !hasError();
+    }
+
+    ZstdStreamBuf::int_type ZstdStreamBuf::underflow() {
+        if (m_mode != Mode::Decompress || hasError() || !m_dstream) {
+            return traits_type::eof();
+        }
+        if (gptr() < egptr()) {
+            return traits_type::to_int_type(*gptr());
+        }
+
+        while (true) {
+            if (m_zstdIn.pos >= m_zstdIn.size) {
+                m_in->read(m_inBuffer.data(), static_cast<std::streamsize>(m_inBuffer.size()));
+                const auto n = m_in->gcount();
+                if (n <= 0) {
+                    if (m_decompressRet != 0) {
+                        setError("Unexpected end of zstd stream");
+                    }
+                    return traits_type::eof();
+                }
+                m_zstdIn.src = m_inBuffer.data();
+                m_zstdIn.size = static_cast<size_t>(n);
+                m_zstdIn.pos = 0;
+            }
+
+            ZSTD_outBuffer zstdOut{m_outBuffer.data(), m_outBuffer.size(), 0};
+            const auto ret = ZSTD_decompressStream(m_dstream, &zstdOut, &m_zstdIn);
+            if (ZSTD_isError(ret)) {
+                setError(ZSTD_getErrorName(ret));
+                return traits_type::eof();
+            }
+            m_decompressRet = ret;
+
+            if (zstdOut.pos > 0) {
+                setg(m_outBuffer.data(), m_outBuffer.data(), m_outBuffer.data() + static_cast<std::ptrdiff_t>(zstdOut.pos));
+                return traits_type::to_int_type(*gptr());
+            }
+
+            if (m_decompressRet == 0 && m_zstdIn.pos >= m_zstdIn.size && m_in->peek() == traits_type::eof()) {
+                return traits_type::eof();
+            }
+        }
+    }
+
+    ZstdStreamBuf::int_type ZstdStreamBuf::overflow(int_type ch) {
+        if (m_mode != Mode::Compress || hasError() || !m_cstream) {
+            return traits_type::eof();
+        }
+        if (traits_type::eq_int_type(ch, traits_type::eof())) {
+            return sync() == 0 ? traits_type::not_eof(ch) : traits_type::eof();
+        }
+        if (pptr() == epptr() && !compressBuffered()) {
+            return traits_type::eof();
+        }
+        *pptr() = traits_type::to_char_type(ch);
+        pbump(1);
+        return ch;
+    }
+
+    std::streamsize ZstdStreamBuf::xsputn(const char *s, std::streamsize count) {
+        if (m_mode != Mode::Compress || hasError() || !m_cstream || count <= 0) {
+            return 0;
+        }
+
+        std::streamsize totalWritten = 0;
+        while (totalWritten < count) {
+            if (pptr() == epptr() && !compressBuffered()) {
+                break;
+            }
+
+            const auto writable = static_cast<std::streamsize>(epptr() - pptr());
+            const auto chunk = std::min(writable, count - totalWritten);
+            std::copy_n(s + totalWritten, chunk, pptr());
+            pbump(static_cast<int>(chunk));
+            totalWritten += chunk;
+        }
+        return totalWritten;
+    }
+
+    int ZstdStreamBuf::sync() {
+        if (m_mode != Mode::Compress || hasError() || !m_cstream) {
+            return hasError() ? -1 : 0;
+        }
+        if (!compressBuffered()) {
+            return -1;
+        }
+        m_out->flush();
+        return m_out->good() ? 0 : -1;
+    }
+
+    bool ZstdStreamBuf::compressBuffered() {
+        if (m_mode != Mode::Compress || hasError() || !m_cstream) {
+            return false;
+        }
+
+        ZSTD_inBuffer zstdIn{pbase(), static_cast<size_t>(pptr() - pbase()), 0};
+        while (zstdIn.pos < zstdIn.size) {
+            ZSTD_outBuffer zstdOut{m_outBuffer.data(), m_outBuffer.size(), 0};
+            const auto ret = ZSTD_compressStream2(m_cstream, &zstdOut, &zstdIn, ZSTD_e_continue);
+            if (ZSTD_isError(ret)) {
+                return setError(ZSTD_getErrorName(ret));
+            }
+            if (zstdOut.pos > 0) {
+                m_out->write(m_outBuffer.data(), static_cast<std::streamsize>(zstdOut.pos));
+                if (!m_out->good()) {
+                    return setError("Failed to write compressed output");
+                }
+            }
+        }
+
+        setp(m_inBuffer.data(), m_inBuffer.data() + m_inBuffer.size());
+        return true;
+    }
+
+    bool ZstdStreamBuf::finishCompression() {
+        while (true) {
+            ZSTD_inBuffer zstdIn{nullptr, 0, 0};
+            ZSTD_outBuffer zstdOut{m_outBuffer.data(), m_outBuffer.size(), 0};
+            const auto ret = ZSTD_compressStream2(m_cstream, &zstdOut, &zstdIn, ZSTD_e_end);
+            if (ZSTD_isError(ret)) {
+                return setError(ZSTD_getErrorName(ret));
+            }
+            if (zstdOut.pos > 0) {
+                m_out->write(m_outBuffer.data(), static_cast<std::streamsize>(zstdOut.pos));
+                if (!m_out->good()) {
+                    return setError("Failed to write compressed output");
+                }
+            }
+            if (ret == 0) {
+                break;
+            }
+        }
+        m_out->flush();
+        if (!m_out->good()) {
+            return setError("Failed to flush compressed output");
+        }
+        return true;
+    }
+
+    bool ZstdStreamBuf::setError(std::string message) {
+        if (m_errorMessage.empty()) {
+            m_errorMessage = std::move(message);
+        }
+        return false;
+    }
+
+}
\ No newline at end of file
diff --git a/src/serializer/zstdstreambuf_p.h b/src/serializer/zstdstreambuf_p.h
new file mode 100644
index 0000000..a7a0084
--- /dev/null
+++ b/src/serializer/zstdstreambuf_p.h
@@ -0,0 +1,63 @@
+#ifndef OPENDSPX_SERIALIZER_ZSTDSTREAMBUF_P_H
+#define OPENDSPX_SERIALIZER_ZSTDSTREAMBUF_P_H
+
+#include <array>
+#include <istream>
+#include <ostream>
+#include <streambuf>
+#include <string>
+
+#include <zstd.h>
+
+namespace opendspx {
+
+    class ZstdStreamBuf final : public std::streambuf {
+    public:
+        explicit ZstdStreamBuf(std::ostream &out, int compressionLevel = ZSTD_CLEVEL_DEFAULT);
+        explicit ZstdStreamBuf(std::istream &in);
+        ~ZstdStreamBuf() override;
+
+        bool good() const;
+        bool hasError() const;
+        const std::string &errorMessage() const;
+
+        bool finish();
+
+    protected:
+        int_type underflow() override;
+        int_type overflow(int_type ch) override;
+        std::streamsize xsputn(const char *s, std::streamsize count) override;
+        int sync() override;
+
+    private:
+        enum class Mode {
+            Compress,
+            Decompress,
+        };
+
+        bool compressBuffered();
+        bool finishCompression();
+        bool setError(std::string message);
+
+        static constexpr size_t BufferSize = 1 << 15;
+
+        Mode m_mode;
+        std::istream *m_in = nullptr;
+        std::ostream *m_out = nullptr;
+
+        ZSTD_CStream *m_cstream = nullptr;
+        ZSTD_DStream *m_dstream = nullptr;
+
+        std::array<char, BufferSize> m_inBuffer{};
+        std::array<char, BufferSize> m_outBuffer{};
+
+        ZSTD_inBuffer m_zstdIn{nullptr, 0, 0};
+        size_t m_decompressRet = 0;
+        bool m_finished = false;
+
+        std::string m_errorMessage;
+    };
+
+}
+
+#endif // OPENDSPX_SERIALIZER_ZSTDSTREAMBUF_P_H
\ No newline at end of file
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index ecee400..d10c026 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,15 +2,6 @@ project(Test)
 
 add_executable(${PROJECT_NAME} main.cpp)
 
-#add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-#        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-#        $<TARGET_FILE:opendspx> $<TARGET_FILE_DIR:${PROJECT_NAME}>
-#)
-
-find_package(QT NAMES Qt6 COMPONENTS Core REQUIRED)
-find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core REQUIRED)
-target_link_libraries(${PROJECT_NAME} PUBLIC Qt${QT_VERSION_MAJOR}::Core)
-
 target_link_libraries(${PROJECT_NAME} PRIVATE
     opendspx::model
     opendspx::serializer
diff --git a/tests/main.cpp b/tests/main.cpp
index 2e32207..24619b9 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -1,7 +1,10 @@
+#include <iostream>
+#include <sstream>
+
 #include <opendspx/model.h>
 #include <opendspxserializer/serializer.h>
 
-using namespace QDspx;
+using namespace opendspx;
 
 const auto data = R"(
 {
@@ -60,7 +63,7 @@ const auto data = R"(
                         "type": "singing",
                         "name": "Verse 1 Vocal",
                         "time": {
-                            "start": 0,
+                            "pos": 0,
                             "length": 7680,
                             "clipStart": 0,
                             "clipLen": 7680
@@ -304,12 +307,7 @@ const auto data = R"(
                                 "transform": []
                             }
                         },
-                        "sources": {
-                            "singer": {
-                                "name": "Default Singer",
-                                "version": "1.0"
-                            }
-                        },
+                        "sources": null,
                         "workspace": {}
                     }
                 ],
@@ -329,7 +327,7 @@ const auto data = R"(
                         "name": "Background Music",
                         "path": "assets/background.wav",
                         "time": {
-                            "start": 0,
+                            "pos": 0,
                             "length": 15360,
                             "clipStart": 0,
                             "clipLen": 15360
@@ -361,9 +359,13 @@ const auto data = R"(
 
 int main() {
     SerializationErrorList errors;
-    auto model = Serializer::deserialize(data, errors);
-    qDebug() << errors.size();
-    auto data1 = Serializer::serialize(model, errors);
-    qDebug().noquote() << QJsonDocument::fromJson(data1).toJson(QJsonDocument::Indented);
+    std::stringstream in(data, std::ios::in);
+    auto model = Serializer::deserialize(in, errors);
+    std::cerr << errors.size() << std::endl;
+    std::stringstream out;
+    Serializer::serialize(out, model, errors, Serializer::FailFast | Serializer::CheckError, true);
+    for (auto ch : out.str()) {
+        std::cout << std::setbase(16) << std::setfill('0') << std::setw(2) << static_cast<int>(static_cast<std::uint8_t>(ch)) << " ";
+    }
     return 0;
 }