> ## Documentation Index > Fetch the complete documentation index at: https://docs.ai-coustics.com/llms.txt > Use this file to discover all available pages before exploring further. # Changelog > Product updates and announcements ## Platform Support * Windows MSVC: the shipped `aic.dll` (x86\_64 and arm64) now statically links the MSVC C runtime, so it no longer requires the Visual C++ Redistributable to be installed. * Windows MSVC: both CRT variants of the static import library are now shipped, `lib/dynamic-crt/aic.lib` and `lib/static-crt/aic.lib`. This lets consumers match their own runtime setting and avoids LNK2038 mismatches for projects building with the default `/MD`, which a `/MT`-only library would break. * Apple: the release artifacts now include an `aic-sdk-apple-xcframework` bundle covering macOS, Mac Catalyst, iOS, tvOS, and visionOS (device and simulator). ## Platform Support * Added Windows GNU/LLVM release targets `x86_64-pc-windows-gnullvm` and `aarch64-pc-windows-gnullvm` ## New Features Support for offline entitlements in JWT licenses. ## New Features This release includes a new `aic_vad_context_get_raw_vad_probability()` API to read the raw output of a VAD model. ## Changes Reduced the necessary output delay of the Processor when using allow\_variable\_frames = true. ## New Features This release includes several new APIs for running our newest audio intelligence model, *Tyto*. The new APIs introduce two new concepts: The `Collector` and the `Analyzer`. * The `Collector` is designed to be placed in the audio thread, buffering audio chunks for later analysis. * The `Analyzer` is designed to be run separately. Analysis models are computationally expensive and cannot run in the audio thread. The analyzer has access to the audio buffered by the collector, and it can access it safely across threads. Initialize the `Collector` with the same configuration as your existing `Processor` and you can call the `aic_collector_buffer_*` APIs in the same manner as the `aic_processor_process_*` APIs. Call `aic_analyzer_analyze_buffered` in a separate thread to obtain an analysis of the latest audio buffered by the `Collector`. ## Platform Support * Fixed a crash on Android during startup ## Platform Support * Added Android targets arm-v7a and x86\_64 ## New Features * Windows release bundles include the DLL import library `aic.dll.lib` * Added iOS simulator arm64 release target `aarch64-apple-ios-sim` * Enabled Rust wrapper support across all Apple targets ## Features ### JWT token support The SDK now accepts JWT-form license keys in addition to the existing license formats. Pass the JWT string as `license_key` to `aic_processor_create` as you would with any other license key: ```c theme={null} aic_processor_create(&processor, model, jwt_string, NULL); ``` JWT licenses are short-lived. Use `aic_processor_context_update_bearer_token` to swap in a renewed token while audio processing continues uninterrupted, the context handle stays valid, and the new token is used for all subsequent authentication against the ai-coustics backend: ```c theme={null} enum AicErrorCode aic_processor_context_update_bearer_token( const struct AicProcessorContext *context, const char *token); ``` In-place updates are only supported when both the originally configured key and the new token are JWTs. If either side is not, the call returns the new error code `AIC_ERROR_CODE_TOKEN_UPDATE_UNSUPPORTED` and the existing token stays in use. ### Voice activity detection models VAD is no longer limited to the energy-based detector. The SDK now also supports dedicated VAD models, which output a per-buffer speech probability. `AIC_VAD_PARAMETER_SENSITIVITY` is interpreted differently depending on the active model: * VAD models: range `0.0` to `1.0`; the probability threshold above which speech is reported. * Energy-based VADs: range `1.0` to `15.0`; energy threshold = `10 ^ (-sensitivity)`. The default sensitivity is now model-specific. ### Configurable OpenTelemetry export interval `AicOtelConfig` has a new field `export_interval_ms` controlling how often OpenTelemetry metrics are exported. Set it to `0` to keep the default of 60 000 ms: ```c theme={null} AicOtelConfig otel = { .enable = true, .session_id = NULL, .export_interval_ms = 5000, // export every 5 seconds }; aic_processor_create(&processor, model, license_key, &otel); ``` ## Features The SDK now supports observability with [OpenTelemetry](https://opentelemetry.io/). See the [documentation](https://docs.ai-coustics.com/guides/observability) for the complete setup guide. `aic_processor_create` takes a new `otel_config` parameter with two usage options: **Environment variable**: pass `NULL` and set `AIC_SDK_OTEL_ENABLE=1` to enable telemetry globally: ```c theme={null} aic_processor_create(&processor, model, license_key, NULL); ``` **Per-session**: pass an `AicOtelConfig` to enable telemetry and associate it with a specific session ID: ```c theme={null} typedef struct AicOtelConfig { bool enable; const char *session_id; // NULL = auto-generate } AicOtelConfig; AicOtelConfig otel = { .enable = true, .session_id = "my-session-id" }; aic_processor_create(&processor, model, license_key, &otel); ``` ## Breaking Changes `aic_processor_create` has a new `otel_config` parameter. Existing call sites must be updated to pass `NULL` as the last argument. ## Improvements * Increased maximum VAD speech hold duration from 100x to 300x the model's window size. ## Bug Fixes * Removed zero-padding when the host frame size does not match the model frame size, which caused unexpected behavior for some models. ## New Features * Added support for Quail Voice Focus 2.1 models. ## Breaking Changes * Quail Voice Focus 2.0 is no longer supported. * Compatible model file version was bumped to 3. ## New Features This release adds an **experimental** feature to export real-time audio processing metrics via OpenTelemetry (OTel). The new feature is currently disabled by default and available for testing on early access only. ## Improvements * Improved performance of telemetry when using multiple processors. ## Fixes * The scaling factor of the STFT now changes depending on the sample rate. ## New features * Support for V2 model files, which includes support for the new Quail Voice Focus 2.0 model. ## Improvements * The parameters of Quail models are no longer fixed. The enhancement level of every model can now be adjusted between 0.0 and 1.0. ## Breaking Changes * V1 model files are no longer supported. * The error `AIC_ERROR_CODE_PARAMETER_FIXED` was removed. * The parameter `AIC_PROCESSOR_PARAMETER_VOICE_GAIN` was removed. * The parameter `AIC_VAD_PARAMETER_SPEECH_HOLD_DURATION` previously held detected speech for half of the specified duration. It has now been changed to better represent the intention of the developer. * The default value for `AIC_VAD_PARAMETER_SPEECH_HOLD_DURATION` was changed from 50 ms to 30 ms to match the existing behavior. ## Fixes * `aic_vad_context_set_parameter` no longer returns an error when trying to set a valid speech hold duration value before calling `aic_processor_initialize`. ## Improvements * Increased the maximum speech hold duration of the VAD from 20 to 100x the model's window size. ## Fixes * Fixed an issue causing the VAD's state to be reset on every `aic_processor_process_*` call. ## Breaking changes * `AIC_ERROR_CODE_MODEL_NOT_INITIALIZED` has been renamed to `AIC_ERROR_CODE_PROCESSOR_NOT_INITIALIZED`. ## Fixes * Fixed an issue allowing users to change processor parameters with certain models This release comes with a number of new features and several breaking changes. Most notably, the C library does no longer include any models, which significantly reduces the library's binary size. The models are now available separately for download at [https://artifacts.ai-coustics.io](https://artifacts.ai-coustics.io). **New license keys required**: License keys previously generated in the [developer platform](https://developers.ai-coustics.com) will no longer work. New license keys must be generated. **Model naming changes**: Quail-STT models are now called "Quail" - These models are optimized for human-to-machine enhancement (e.g., Speech-to-Text (STT) applications). Quail models are now called "Sparrow" - These models are optimized for human-to-human enhancement (e.g., voice calls, conferencing). This naming change clarifies the distinction between STT-focused models and human-to-human communication model **Major architectural changes**: The API has been restructured to separate model data from processing instances. What was previously called `AicModel` (which handled both model data and processing) has been split into: * `AicModel`: Now represents only the ML model data loaded from files or memory * `AicProcessor`: New type that performs the actual audio processing using a model * Multiple processors can share the same model, allowing efficient resource usage across streams * Model instances are reference-counted internally; `aic_model_destroy` can be called immediately after creating processors, and the model will be freed automatically when the last processor using it is destroyed * To change parameters, reset the processor and get the output delay, a processor context must now be created via `aic_processor_context_create`. This context can be freely moved between threads ## New features * Models now load from files via `aic_model_create_from_file`. * Models can also be created from in-memory buffers with `aic_model_create_from_buffer`. * Added new `aic_model_get_id` API to query the id of a model. * A single model handle can be shared across multiple processors. * Added processor handles with `aic_processor_create` so each stream can be initialized independently from a shared model while sharing weights. * Added `aic_get_compatible_model_version` to query the required model version for this SDK. * Added context-based APIs for thread-safe control operations: * `aic_processor_context_create` and `aic_processor_context_destroy` for processor context management * `aic_vad_context_create` and `aic_vad_context_destroy` for VAD context management * Model query APIs moved to model handles: * `aic_model_get_optimal_sample_rate` - gets optimal sample rate for a model * `aic_model_get_optimal_num_frames` - gets optimal frame count for a model at given sample rate * Added new error codes for model loading: * `AIC_ERROR_CODE_MODEL_INVALID` * `AIC_ERROR_CODE_MODEL_VERSION_UNSUPPORTED` * `AIC_ERROR_CODE_MODEL_FILE_PATH_INVALID` * `AIC_ERROR_CODE_FILE_SYSTEM_ERROR` * `AIC_ERROR_CODE_MODEL_DATA_UNALIGNED` ## Breaking changes * License keys previously generated in the [developer platform](https://developers.ai-coustics.com) will no longer work. New license keys have to be generated. * Existing `aic_model_*` processing and configuration APIs have been renamed to `aic_processor_*`. * Removed `AicModelType` enum; callers must supply a model file or aligned buffer instead of selecting a built-in model. * License keys are now provided to `aic_processor_create` rather than model creation. * Renamed `AicEnhancementParameter` to `AicProcessorParameter` (`AIC_PROCESSOR_PARAMETER_*`). * VAD APIs now use `AicVadContext` handles and bind to processor handles instead of model handles: * `aic_vad_create` → `aic_vad_context_create` (takes `const AicProcessor*` instead of `AicModel*`) * `aic_vad_destroy` → `aic_vad_context_destroy` * `aic_vad_is_speech_detected` → `aic_vad_context_is_speech_detected` (takes `const AicVadContext*`) * `aic_vad_get_parameter` → `aic_vad_context_get_parameter` (takes `const AicVadContext*`) * `aic_vad_set_parameter` → `aic_vad_context_set_parameter` (takes `const AicVadContext*`) * Processor control APIs now take `AicProcessorContext` handles created via `aic_processor_context_create`: * `aic_model_reset` → `aic_processor_context_reset` (takes `const AicProcessorContext*`) * `aic_model_get_parameter` → `aic_processor_context_get_parameter` (takes `const AicProcessorContext*`) * `aic_model_set_parameter` → `aic_processor_context_set_parameter` (takes `const AicProcessorContext*`) * `aic_get_output_delay` → `aic_processor_context_get_output_delay` (takes `const AicProcessorContext*`) * Model query APIs moved to model methods: * `aic_get_optimal_sample_rate` → `aic_model_get_optimal_sample_rate` * `aic_get_optimal_num_frames` → `aic_model_get_optimal_num_frames` ## Fixes * Improved thread safety. * Fixed an issue where the allocated size for an FFT operation could be incorrect, leading to a crash. ## New features * Added new VAD parameter `AIC_VAD_PARAMETER_MINIMUM_SPEECH_DURATION` used to control for how long speech needs to be present in the audio signal before the VAD considers it speech. ## Breaking changes * Replaced VAD parameter `AIC_VAD_PARAMETER_LOOKBACK_BUFFER_SIZE` with `AIC_VAD_PARAMETER_SPEECH_HOLD_DURATION`, used to control for how long the VAD continues to detect speech after the audio signal no longer contains speech. ## New features * Added new Quail Voice Focus STT model (`AIC_MODEL_TYPE_QUAIL_VF_STT_L16`), purpose-built to isolate and elevate the foreground speaker while suppressing both interfering speech and background noise. * Added new variants of the Quail STT model: `AIC_MODEL_TYPE_QUAIL_STT_L8`, `AIC_MODEL_TYPE_QUAIL_STT_S16` and `AIC_MODEL_TYPE_QUAIL_STT_S8`. * Added `aic_model_process_sequential` for sequential channel data in a single buffer ## Breaking changes * `AIC_MODEL_TYPE_QUAIL_STT` was renamed to `AIC_MODEL_TYPE_QUAIL_STT_L16` * `aic_vad_create` signature changed: the `model` parameter is no longer `const` ## Fixes * VAD now works correctly when `AIC_ENHANCEMENT_PARAMETER_ENHANCEMENT_LEVEL` is set to 0 or `AIC_ENHANCEMENT_PARAMETER_BYPASS` is enabled (previously non-functional in these cases) ## Features * **Quail STT** (`AIC_MODEL_TYPE_QUAIL_STT`): Our newest speech enhancement model is optimized for human-to-machine interaction (e.g., voice agents, speech-to-text). This model operates at a native sample rate of 16 kHz and uses fixed enhancement parameters that cannot be changed during runtime. The model is also compatible with our VAD. ## Breaking Changes * Removed `AIC_ENHANCEMENT_PARAMETER_NOISE_GATE_ENABLE` as it is now a fixed part of our VAD. * Added new error code `AIC_ERROR_CODE_PARAMETER_FIXED` returned when attempting to modify a parameter of a model with fixed parameters. ## Fixes * Fixed an issue where `aic_vad_is_speech_detected` always returned `true` when `AIC_VAD_PARAMETER_LOOKBACK_BUFFER_SIZE` was set to `1.0`. ## Features * **Internal library patching**: Static libraries are now patched internally to simplify usage from Rust, reducing integration complexity * **Windows ARM64 support**: Added Windows ARM64 as a supported target platform ## Breaking Changes * **Additional system library dependencies**: On macOS and Windows, the following system libraries must now be linked: * **Windows**: `Synchronization` and `bcryptprimitives` * **macOS**: `CoreFoundation` ## Features * **Voice Activity Detection**: This release adds a new Quail-based VAD. The VAD automatically uses the output of a Quail model to calculate a voice activity prediction. **Added VAD functions** ```C theme={null} enum AicErrorCode aic_vad_create(struct AicVad **vad, const struct AicModel *model); void aic_vad_destroy(struct AicVad *vad); enum AicErrorCode aic_vad_is_speech_detected(struct AicVad *vad, bool *value); enum AicErrorCode aic_vad_set_parameter(struct AicVad *vad, enum AicVadParameter parameter, float value); enum AicErrorCode aic_vad_get_parameter(const struct AicVad *vad, enum AicVadParameter parameter, float *value); ``` **Added VAD parameters** ```C theme={null} typedef enum AicVadParameter { AIC_VAD_PARAMETER_LOOKBACK_BUFFER_SIZE = 0, AIC_VAD_PARAMETER_SENSITIVITY = 1, } AicVadParameter; ``` ## Breaking Changes * `AicParameter` was renamed to `AicEnhancementParameter`. **Old** ```C theme={null} typedef enum AicParameter { AIC_PARAMETER_BYPASS = 0, AIC_PARAMETER_ENHANCEMENT_LEVEL = 1, AIC_PARAMETER_VOICE_GAIN = 2, AIC_PARAMETER_NOISE_GATE_ENABLE = 3, } AicParameter; ``` **New** ```C theme={null} typedef enum AicEnhancementParameter { AIC_ENHANCEMENT_PARAMETER_BYPASS = 0, AIC_ENHANCEMENT_PARAMETER_ENHANCEMENT_LEVEL = 1, AIC_ENHANCEMENT_PARAMETER_VOICE_GAIN = 2, AIC_ENHANCEMENT_PARAMETER_NOISE_GATE_ENABLE = 3, } AicEnhancementParameter; ``` ## Features * **Self-Service Licenses**: Starting with this release, you can use self-service licenses directly from our developer platform. * **Usage-Based Telemetry**: This release introduces a new telemetry feature that collects usage data, paving the way for future usage-based pricing models such as pay-per-minute billing. * **What we collect**: We collect only the processing time used and some diagnostic data * **Privacy**: We do not collect any information about your audio content. Your audio never leaves your device during our processing. * **Requirements**: Requires a constant internet connection. If the SDK cannot be activated online, enhancement will stop after 10 seconds. If telemetry data cannot be sent, enhancement will stop after 5 minutes. When enhancement is stopped an error will be returned, the audio will be bypassed and the processing delay will be still applied to ensure an uninterrupted audio stream without discontinuities. * **Error Handling**: When processing is bypassed because our backend cannot be reached or does not allow you to process, the process functions will return `AIC_ERROR_CODE_ENHANCEMENT_NOT_ALLOWED`. Make sure to handle this error code in your implementation. * **Offline Licenses**: If you cannot provide a constant internet connection, please contact us to obtain a special offline license that does not require telemetry. ## Breaking Changes * **Updated Error Codes**: Renumbered and expanded error codes with additional license-related errors. ### Old Error Codes | Error Code | Value | | ----------------------------------------- | ----- | | `AIC_ERROR_CODE_SUCCESS` | 0 | | `AIC_ERROR_CODE_NULL_POINTER` | 1 | | `AIC_ERROR_CODE_LICENSE_INVALID` | 2 | | `AIC_ERROR_CODE_LICENSE_EXPIRED` | 3 | | `AIC_ERROR_CODE_UNSUPPORTED_AUDIO_CONFIG` | 4 | | `AIC_ERROR_CODE_AUDIO_CONFIG_MISMATCH` | 5 | | `AIC_ERROR_CODE_NOT_INITIALIZED` | 6 | | `AIC_ERROR_CODE_PARAMETER_OUT_OF_RANGE` | 7 | | `AIC_ERROR_CODE_SDK_ACTIVATION_ERROR` | 8 | ### New Error Codes | Error Code | Value | Notes | | -------------------------------------------- | ----- | ------------------------------------------------------------------------------------------------------------- | | `AIC_ERROR_CODE_SUCCESS` | 0 | Unchanged | | `AIC_ERROR_CODE_NULL_POINTER` | 1 | Unchanged | | `AIC_ERROR_CODE_PARAMETER_OUT_OF_RANGE` | 2 | Renumbered from 7 | | `AIC_ERROR_CODE_MODEL_NOT_INITIALIZED` | 3 | Renamed from `AIC_ERROR_CODE_NOT_INITIALIZED`, renumbered from 6 | | `AIC_ERROR_CODE_AUDIO_CONFIG_UNSUPPORTED` | 4 | Renamed from `AIC_ERROR_CODE_UNSUPPORTED_AUDIO_CONFIG` | | `AIC_ERROR_CODE_AUDIO_CONFIG_MISMATCH` | 5 | Unchanged | | `AIC_ERROR_CODE_ENHANCEMENT_NOT_ALLOWED` | 6 | **New.** SDK key was not authorized or process failed to report usage. Check if you have internet connection. | | `AIC_ERROR_CODE_INTERNAL_ERROR` | 7 | **New.** Internal error occurred. Contact support. | | `AIC_ERROR_CODE_LICENSE_FORMAT_INVALID` | 50 | Renamed from `AIC_ERROR_CODE_LICENSE_INVALID`, renumbered from 2 | | `AIC_ERROR_CODE_LICENSE_VERSION_UNSUPPORTED` | 51 | **New.** License version is not compatible with the SDK version. Update SDK or contact support. | | `AIC_ERROR_CODE_LICENSE_EXPIRED` | 52 | Renumbered from 3 | **Removed:** `AIC_ERROR_CODE_SDK_ACTIVATION_ERROR` has been removed and split into specific license errors. ## Fixes * Fixed an issue where, after a successful initialization, a subsequent initialization error would not properly block processing, potentially allowing operations on a partially initialized model. * Fixed an issue where toggling bypass mode or switching enhancement levels could produce discontinuities. ### Breaking Changes * **Variable number of frames supported**: The `aic_model_process` function now supports a variable number of frames per call. To enable this feature, use the new `allow_variable_frames` parameter in the `initialize` function: ```C theme={null} enum AicErrorCode aic_model_initialize(struct AicModel *model, uint32_t sample_rate, uint16_t num_channels, size_t num_frames, bool allow_variable_frames); ``` Set `allow_variable_frames` to `true` to enable variable frame processing, or `false` to maintain the previous fixed frame behavior. Note that enabling variable frames results in higher processing delay. * **New bypass parameter**: A new parameter `AIC_PARAMETER_BYPASS` has been added to control audio processing bypass while preserving algorithmic delay. When enabled, the input audio passes through unmodified, but the output is still delayed by the same amount as during normal processing. This ensures seamless transitions when toggling enhancement on/off without audible clicks or timing shifts. * **Sample rate parameter added to `aic_get_optimal_num_frames`**: The function now takes `sample_rate` as an argument to make the dependency between sample rate and optimal frame count more explicit: ```C theme={null} enum AicErrorCode aic_get_optimal_num_frames(const struct AicModel *model, uint32_t sample_rate, size_t *num_frames); ``` ### Fixes * **Model state reset during pause**: The internal model state is now automatically reset when processing is paused (e.g., when bypass is enabled or enhancement level is set to 0). This ensures a clean state when processing resumes. * **`aic_model_reset` now resets all DSP components**: The reset operation now ensures that all internal DSP components are properly reset, providing a more thorough clean state. ### Updates * **Updated low-sample rate models**: 8- and 16 KHz Quail models updated with improved speech enhancement performance. ### Bug Fixes * **Fixed output delay issue**: Resolved reported output delay problems affecting `AIC_MODEL_QUAIL_XS` and `AIC_MODEL_QUAIL_XXS` models * **Fixed audio quality degradation**: Corrected audio distortion that occurred when using enhancement levels below 1.0 with the affected models ### Features * A new resampling technique makes resampling much more robust without adding additional latency or performance overhead * New models for different sample rates are now available (16 kHz and 8 kHz) * The noise gate algorithm has been improved, which leads to better quality * The output of `aic_get_optimal_num_frames` now changes with sample rate so you can always have the lowest output delay * The model reset now works as expected and resets the internal model state correctly ### Breaking Changes * `AIC_MODEL_QUAIL_L` is now called `AIC_MODEL_QUAIL_L48` * `AIC_MODEL_QUAIL_S` is now called `AIC_MODEL_QUAIL_S48` * `get_library_version` is now called `aic_get_sdk_version` * `aic_get_processing_latency` is now called `aic_get_output_delay` * `AIC_PARAMETER_ENHANCEMENT_LEVEL_SKEW_FACTOR` has been removed because it led to confusion. The enhancement level is more predictable this way, and a value of 0.0 is always a bypass. If you want to skew the enhancement slider, this has to be done on your end.