안녕하세요. VMONSTER의 AI Engineer 김재민입니다. VMONSTER는 실시간 AI 아바타 인터페이스를 구현하기 위한 대화형 스트리밍 SDK를 지속적으로 개발하고 있습니다.
지금까지는 웹 환경에 특화된 JavaScript(TypeScript) 기반의 SDK를 제공하여, 웹 브라우저를 통한 AI와의 실시간 대화를 가능하게 했습니다. 하지만 서비스가 점차 성장하면서 macOS, Windows와 같은 데스크톱 플랫폼뿐만 아니라 Android, iOS 등 다양한 모바일 플랫폼에서도 일관된 성능과 안정성으로 동작할 수 있는 SDK의 필요성을 느끼게 되었습니다. 이러한 배경에서 저는 Rust 언어를 활용해 SDK의 코어를 새롭게 설계하는 도전을 시작했습니다. 현재 이 프로젝트는 아직 개발 초기 단계(알파 버전)에 있으며, 이 글을 통해 Rust로 재구성된 SDK 코어가 가지는 잠재력과 가능성, 그리고 그 개발 과정을 미리 소개하고자 합니다.
1. 왜 새로운 SDK가 필요했나?
기존 웹 SDK는 웹 브라우저에 완벽히 최적화된 형태로 제공되었습니다. 하지만 웹 환경 이외의 네이티브 데스크톱 앱이나 모바일 앱과 같은 환경에서는 직접 활용하기에는 제약이 많았습니다. 예컨대, 모바일 환경에서는 SDK의 기능을 활용하기 위해 웹뷰(WebView)를 사용하는 등 우회적인 방법을 사용해야 하고, 이는 앱의 복잡도와 성능 저하로 이어질 수 있습니다.
특히 앞으로 데스크톱과 모바일 플랫폼에서도 동일한 기능을 제공하려면, 각 플랫폼의 특성과 요구사항을 개별적으로 고려하여 새롭게 SDK를 설계하고 유지보수하는 큰 부담이 예상되었습니다. 이는 결과적으로 코드 중복과 관리의 어려움으로 이어질 가능성이 높았으며, 기능을 추가하거나 변경 사항이 발생할 때마다 각 플랫폼의 SDK를 별도로 업데이트해야 하는 과정에서 많은 시간과 비용이 소모될 것으로 보였습니다. 이러한 상황을 극복하기 위해, 하나의 공통된 코어 라이브러리를 구축하고, 플랫폼에 특화된 기능만 얇은 레이어로 제공하여 모든 플랫폼을 효과적으로 관리할 수 있는 방식을 고민하게 되었습니다.
2. Rust를 선택한 이유
제가 여러 언어들 가운데 Rust를 선택한 이유는 다음과 같은 강력한 장점들 때문입니다.
크로스 플랫폼 컴파일과 일관된 성능 보장
Rust는 언어 차원에서 강력한 크로스 플랫폼 컴파일(cross-compilation)을 지원합니다. 하나의 코드베이스를 바탕으로 macOS, Windows, Linux, Android, iOS 등 다양한 플랫폼에서 즉시 사용 가능한 네이티브 바이너리를 생성할 수 있습니다. 또한, Rust의 컴파일러는 각 플랫폼의 CPU 아키텍처에 최적화된 코드를 생성하므로, 플랫폼 간 동작과 성능의 일관성을 자연스럽게 확보할 수 있습니다.
FFI를 활용한 플랫폼별 통합 구조
Rust가 제공하는 FFI(Foreign Function Interface)를 활용하면 작성된 SDK 코어를 공유 라이브러리(cdylib) 형태로 빌드하여 각 플랫폼의 네이티브 언어에서 직접 호출할 수 있습니다.
Android 플랫폼에서는 Rust 라이브러리를 JNI(Java Native Interface)를 통해 Kotlin이나 Java 코드에서 직접 호출할 수 있습니다.
iOS/macOS 플랫폼에서는 Rust 라이브러리를 Swift 또는 Objective-C에서 간단한 브리지 헤더를 통해 호출할 수 있습니다.
Windows 환경에서는 Rust로 빌드된 DLL을 C#, C++ 등의 네이티브 언어에서 간편하게 호출할 수 있습니다.
이러한 FFI 접근은 플랫폼별로 별도의 복잡한 기능 구현 없이, 플랫폼에 특화된 UI 및 시스템 API만 얇은 레이어로 유지하고 복잡한 스트리밍 로직과 데이터 처리는 Rust SDK Core에서 일괄적으로 관리할 수 있어 유지보수의 효율성이 크게 높아집니다.
3. 하나의 코어, 모든 플랫폼 연결하기
Rust SDK 코어의 핵심 목표는 하나의 코드베이스로 다양한 플랫폼을 지원할 수 있는 아키텍처를 구성하는 것입니다. 이를 위해, Rust 기반의 SDK 코어가 각 플랫폼의 특성에 맞게 쉽게 호출될 수 있도록 명확한 FFI 인터페이스를 제공해야 합니다.
Rust SDK Core를 중심으로 각 플랫폼 SDK가 연결되는 구조
중복 코드의 최소화: 공통된 핵심 기능을 Rust SDK Core에서 한 번만 구현하고 관리할 수 있어 중복 코드를 최소화합니다.
일관성 있는 업데이트: SDK Core에서 수정이나 기능 확장이 발생하면 각 플랫폼의 SDK는 별도의 추가 개발 없이 SDK Core를 업데이트하여 손쉽게 개선 사항을 반영할 수 있습니다.
플랫폼별 특화된 기능의 분리: 각 플랫폼의 특화 기능은 플랫폼 SDK 레이어에서 독립적으로 관리할 수 있어, 고유한 요구사항에 빠르고 유연한 대처가 가능합니다.
위에서 소개한 것처럼 Rust를 도입하여 새롭게 설계한 VMONSTER의 SDK Core는 각 플랫폼에서 발생할 수 있는 중복 코드 문제와 유지보수 부담을 해소해줄 것입니다. 특히 플랫폼 특화 기능을 분리한 구조 덕분에, 각 플랫폼의 요구사항이 추가되거나 바뀌더라도 빠르고 유연하게 대응할 수 있는 높은 확장성을 가질 것으로 기대됩니다.
4. 데모로 확인한 크로스플랫폼 가능성
Rust SDK 코어의 성능과 사용성을 빠르게 검증하기 위해, 저는 Godot 엔진을 사용하여 Windows와 macOS 환경에서 간단한 데모를 제작했습니다. 이 데모는 사용자가 텍스트로 입력하면, 이를 Rust SDK Core를 통해 서버로 전송하고 AI가 실시간으로 생성한 영상 스트림을 수신하여 화면에 표시하는 형태로 동작합니다.
Godot 엔진으로 제작한 Windows·macOS 크로스 플랫폼 데모
Godot 엔진을 선택한 이유는 비교적 가볍고 빠르게 크로스 플랫폼 환경을 지원할 수 있기 때문이고 Rust SDK Core의 크로스 플랫폼 활용성을 빠르게 확인하기에 적합했습니다. 실제로 이 데모는 gdext를 통해 Rust로 구현된 코어를 그대로 사용하여 두 플랫폼 간 코드 수정 없이 거의 동일한 성능과 안정성을 보여주었습니다.
이번 데모를 통해 Rust SDK Core가 실제 크로스 플랫폼 환경에서 효과적으로 작동할 수 있음을 빠르게 확인할 수 있었습니다. 텍스트 입력과 실시간 영상 스트리밍이라는 기본적인 흐름뿐만 아니라, Rust 기반의 공통 로직이 각 플랫폼에 거의 수정 없이 동일한 성능과 안정성으로 제공될 수 있음을 입증했습니다. 앞으로 데스크톱 외에 모바일 환경까지 확장해도 같은 구조가 적용 가능하다는 가능성을 미리 확인할 수 있었습니다.
이번 데모는 간단한 수준이지만, 앞으로 Windows와 macOS용 SDK를 1차적으로 배포하고, 그 후 Android, 나아가 iOS 플랫폼으로 지원을 확장하는 과정에서도 동일한 Rust 코어를 그대로 활용하여 관리 부담을 최소화할 수 있을 것으로 기대합니다.
5. 기존 웹 SDK와 Rust SDK의 공존
Rust 기반 SDK Core가 기존 JavaScript 기반 웹 SDK를 완전히 대체하는 것은 아닙니다. 현재 웹 브라우저 환경에서는 여전히 기존의 검증된 JavaScript SDK를 기본적인 솔루션으로 제공합니다. Rust SDK Core는 웹 환경이 아닌 데스크톱 및 모바일 앱과 같은 플랫폼을 위한 보완 솔루션으로 개발되며, 현재는 두 솔루션을 병행하는 형태로 제공할 계획입니다.
장기적으로는 Rust 코어가 충분히 안정화되고 웹 환경에서의 성능과 호환성 제약을 해결한 뒤, WebAssembly(WASM)를 활용해 웹 브라우저 환경에서도 Rust SDK Core를 제공하는 방안을 고려하고 있습니다. Rust는 WASM을 공식적으로 지원하기 때문에 이론적으로 브라우저에서도 Rust SDK Core의 강점을 활용할 수 있을 것입니다.
6. 앞으로의 계획과 기대
Rust로 새롭게 구현한 VMONSTER 대화형 스트리밍 SDK Core는 현재 초기 프로토타입 단계(알파 버전)에 있습니다. 그럼에도 내부 테스트와 간단한 데모 앱 제작을 통해, Rust 기반 SDK가 가진 안정성 및 높은 크로스 플랫폼 확장 가능성을 확인할 수 있었습니다. 앞으로의 계획은 다음과 같습니다.
우선적으로 Windows와 macOS SDK 안정화 및 1차 배포
Android 플랫폼 지원 확대 및 SDK 안정화
이후 iOS 플랫폼으로의 지원 확장 및 SDK 배포
플랫폼 간 기능 일관성 확보 및 API 편의성 개선
문서화 및 예제 제공
Rust를 도입하여 SDK Core를 재설계하는 이번 프로젝트는 크로스 플랫폼 환경에서의 관리 효율성과 장기적인 안정성을 확보하기 위한 중요한 전략적 선택이라 생각합니다. 아직 초기 단계이지만, 이번 데모를 통해 충분한 가능성과 잠재력을 확인했으며, 앞으로 브이몬스터 서비스의 경쟁력을 크게 높여줄 수 있을 것으로 기대합니다. 이 과정에서 얻은 기술적 인사이트는 앞으로도 브이몬스터 블로그에 꾸준히 공유할 예정입니다. 감사합니다.
Hello, I’m Jaemin Kim, an AI Engineer at VMONSTER. VMONSTER continuously develops a conversational streaming SDK for building real-time AI avatar interfaces.
Until now, we have provided a JavaScript (TypeScript)–based SDK specialized for the web environment, enabling real-time conversations with AI through the web browser. However, as our service has gradually grown, we have come to recognize the need for an SDK that can operate with consistent performance and stability not only on desktop platforms such as macOS and Windows, but also on a variety of mobile platforms such as Android and iOS. Against this backdrop, I took on the challenge of redesigning the core of the SDK from scratch using the Rust language. This project is still in its early development stage (alpha version), and through this article I would like to give an advance introduction to the potential and possibilities of the Rust-rebuilt SDK core, along with its development process.
1. Why Did We Need a New SDK?
The existing web SDK was provided in a form perfectly optimized for the web browser. However, in environments other than the web—such as native desktop apps or mobile apps—there were many constraints to using it directly. For example, in a mobile environment, you would have to use workarounds such as a WebView to take advantage of the SDK’s features, which can lead to increased app complexity and degraded performance.
In particular, to provide the same functionality on desktop and mobile platforms going forward, we anticipated a significant burden of designing and maintaining a new SDK by individually accounting for the characteristics and requirements of each platform. This was highly likely to lead to code duplication and management difficulties, and it appeared that a great deal of time and cost would be consumed in the process of separately updating each platform’s SDK whenever a feature was added or a change occurred. To overcome this situation, we began to consider an approach in which we build a single shared core library and provide only platform-specific features as a thin layer, allowing us to manage all platforms effectively.
2. Why We Chose Rust
The reason I chose Rust among various languages comes down to the following powerful advantages.
Cross-platform compilation and guaranteed consistent performance
Rust provides powerful cross-compilation support at the language level. Based on a single codebase, it can generate native binaries that are immediately usable on a variety of platforms such as macOS, Windows, Linux, Android, and iOS. In addition, because the Rust compiler generates code optimized for each platform’s CPU architecture, consistency of behavior and performance across platforms is naturally secured.
A per-platform integration structure leveraging FFI
By leveraging the FFI (Foreign Function Interface) that Rust provides, the written SDK core can be built as a shared library (cdylib) and called directly from each platform’s native language.
On the Android platform, the Rust library can be called directly from Kotlin or Java code through JNI (Java Native Interface).
On the iOS/macOS platforms, the Rust library can be called from Swift or Objective-C through a simple bridging header.
On Windows, a DLL built with Rust can be conveniently called from native languages such as C# and C++.
This FFI approach means that, without separately implementing complex features for each platform, only the platform-specific UI and system APIs are kept as a thin layer while the complex streaming logic and data processing are managed collectively in the Rust SDK Core, greatly increasing maintenance efficiency.
3. One Core, Connecting Every Platform
The key goal of the Rust SDK core is to compose an architecture that can support a variety of platforms with a single codebase. To achieve this, the Rust-based SDK core must provide clear FFI interfaces so that it can be easily called in a way suited to the characteristics of each platform.
How each platform SDK connects around the Rust SDK Core.
Minimizing duplicate code: common core functionality can be implemented and managed just once in the Rust SDK Core, minimizing duplicate code.
Consistent updates: when a modification or feature extension occurs in the SDK Core, each platform’s SDK can easily reflect the improvements simply by updating the SDK Core, without separate additional development.
Separation of platform-specific features: each platform’s specialized features can be managed independently in the platform SDK layer, enabling fast and flexible responses to unique requirements.
As introduced above, VMONSTER’s SDK Core, newly designed with Rust, will resolve the duplicate-code problems and maintenance burdens that can arise on each platform. In particular, thanks to the structure that separates platform-specific features, we expect it to have high extensibility that can respond quickly and flexibly even as each platform’s requirements are added or changed.
4. Cross-platform Potential Confirmed Through a Demo
To quickly validate the performance and usability of the Rust SDK core, I built a simple demo on Windows and macOS using the Godot engine. This demo works as follows: when the user enters text, it is sent to the server through the Rust SDK Core, and the video stream generated by the AI in real time is received and displayed on screen.
A cross-platform demo on Windows and macOS, built with the Godot engine.
The reason I chose the Godot engine is that it is relatively lightweight and can support a cross-platform environment quickly, making it well suited for rapidly verifying the cross-platform usability of the Rust SDK Core. In fact, this demo used the core implemented in Rust as-is through gdext, and showed nearly identical performance and stability across the two platforms without any code modifications.
Through this demo, we were able to quickly confirm that the Rust SDK Core can operate effectively in a real cross-platform environment. Beyond the basic flow of text input and real-time video streaming, it proved that the Rust-based common logic can be delivered to each platform with virtually no modifications, at the same performance and stability. We were able to confirm in advance the possibility that the same structure can be applied even when we expand beyond desktop to mobile environments in the future.
This demo is simple in scope, but we expect that as we first release the SDK for Windows and macOS, and then expand support to Android and further to the iOS platform, we will be able to minimize the management burden by reusing the same Rust core as-is.
5. Coexistence of the Existing Web SDK and the Rust SDK
The Rust-based SDK Core does not entirely replace the existing JavaScript-based web SDK. In the web browser environment, we still provide the existing, proven JavaScript SDK as the default solution. The Rust SDK Core is being developed as a complementary solution for platforms such as desktop and mobile apps rather than the web environment, and for now we plan to provide both solutions in parallel.
In the long term, after the Rust core is sufficiently stabilized and the performance and compatibility constraints in the web environment are resolved, we are considering an approach to provide the Rust SDK Core in the web browser environment as well by leveraging WebAssembly (WASM). Because Rust officially supports WASM, in theory the strengths of the Rust SDK Core could be leveraged in the browser as well.
6. Future Plans and Expectations
The VMONSTER conversational streaming SDK Core newly implemented in Rust is currently at the early prototype stage (alpha version). Even so, through internal testing and building a simple demo app, we were able to confirm the stability and high cross-platform scalability that the Rust-based SDK possesses. Our plans going forward are as follows.
First, stabilize the Windows and macOS SDKs and make an initial release.
Expand support for the Android platform and stabilize the SDK.
Subsequently expand support to the iOS platform and release the SDK.
Secure feature consistency across platforms and improve API convenience.
Provide documentation and examples.
This project of redesigning the SDK Core by adopting Rust is, I believe, an important strategic choice to secure management efficiency and long-term stability in a cross-platform environment. It is still in its early stages, but through this demo we have confirmed ample possibility and potential, and we expect it to significantly strengthen the competitiveness of the VMONSTER service going forward. We plan to continue sharing the technical insights gained in this process on the VMONSTER blog. Thank you.
