All changes in [[UnreleasedVersion]].
uniffi_bindgen: Renamed thethrows()method ofFunction,Method, andConstructortothrows_str(). Added a newthrows()method that returns a boolean.
- Added support for exceptions in callback interface methods.
- Improved error stringifying on Kotlin and Ruby (the
messageandto_smethods respectively).
- Renamed the
uniffi_bindgencydlibargument tolib_file, since it can also accept static libraries
- The
guess_crate_rootfunction is now public
- The UDL can contain identifiers which are also keywords in Swift, except in namespace functions.
- Fix callback interface init signature in Rust scaffolding
- Drop unused dependencies
- Update to MSRV 1.61.0
- Fixed a small bug in the 0.19.4 release, where the extraneous
r#was present in the HashMap generated scaffolding.
- Implement Timestamp and Duration types in Ruby backend.
- Fixed in a bug where callback interfaces with arguments that include underscores do not get converted to camelCase on Swift.
- Fixed sccache issue with the
askama.tomlconfig file.
- Fixed the dependency from
uniffi_build->uniffi_bindgen
- breaking for external binding generators, the
FFIType::RustArcPtrnow includes an innerString. The string represents the name of the object theRustArcPtrwas derived from. - Kotlin exception names are now formatted as strict UpperCamelCase. Most names shouldn't change, but names that use one word with all caps will be affected (for example
URL->Url,JSONException->JsonException)
- The UDL can contain identifiers which are also keywords in Rust, Python or Kotlin.
- When custom types are used in function/method signatures UniFFI will now use
the UDL name for that type and create a typealias to the concrete type. In the
URL example,
this means the type will be now appear on Kotlin as
Urlrather thanURL. Any existing code should continue to work because of the typealias, but this might affect your generated documentation and/or code completion. - For Python libraries the native library is now loaded from an absolute path. The shared library (
*.dllon Windows,*.dylibon macOS and.soon other platforms) must be placed next to the Python wrapper code.
- Allow record types with arbitrary key types
- Record types can now contain any hashable type as its key. This is implemented for Kotlin, Python and Swift
- Python
- Added support for default values in dictionaries
- Generated Python code is now annotated to avoid mypy type checking
- Kotlin
- Added external type support
- Swift
- Fix test helper code to work with Swift 5.6
- Wrapped types have been renamed custom types.
- The UDL attribute is now
[Custom]instead of[Wrapped] - The trait name has been renamed to
UniffiCustomTypeConverterfromUniffiCustomTypeWrapper - The method names of that trait have been renamed to
into_custom()/from_custom()instead ofwrap()andunwrap() - The associated type has been renamed to
Builtininstead ofWrapped
- The UDL attribute is now
- Custom types (formerly wrapped) now can be configured on the bindings side as well as the scaffolding side. See the "Custom Types" section of the manual for details.
- Kotlin now prefixes more local UniFFI variables with the
_char to avoid conflicts with user-defined names. - Updated Kotlin to use the
FfiConverterpattern (#1144) - Documentation updates: Added a doc comparing UniFFI to Diplomat. Added a README note describing the foreign languages we currently support.
- Fixed
RustCallStatus.__str__implementation on Python - Fixed the version numbers in the CHANGELOG compare links.
- Error handling when converting custom types has been updated. If your
wrap()function returns anErr, in some cases it now may not panic but instead return the error declared by the function.
- Python: Added Callback Interface support
- Swift bindings can now omit argument labels in generated functions using
omit_argument_labels = truein the configuration.
- Kotlin now generates valid code for optional timestamps/durations.
(Note that v0.15.0 was accidentally published, then yanked. v0.15.1 should be used instead)
- Previously, an interface which didn't declare a constructor got a default one anyway, making it impossible to decline to provide one. This is no longer true, so if your interface wants a constructor, you must add one explicitly.
-
Kotlin and Swift, like Python, now support simple "wrapped" types.
-
The Python backend has been refactored to more closely match the other backends, but this should be invisible to consumers.
-
The Swift and Kotlin backends have had minor tweaks.
-
The kotlin backend now explicitly checks for a null pointer in cases where it should be impossible to help us diagnose issues seen in the wild. See #1108.
- The
build_foreign_language_testcases!macro now takes an array of UDL files as the first argument.
- Swift: Added Callback Interface support
- Swift: Refactored codegen to better match Kotlin / Unit of Code
- Kotlin: Added some defensive programming around
RustBufferBuilder.discard()
-
The Rust implementations of all
dictionary,enumorerrortypes defined in UDL must be public. If you see errors like:private type <type-name> in public interfaceor similar, please declare the types aspubin your Rust code. -
Errors declared using the
[Error] enumsyntax will now expose the error string from Rust to the foreign language bindings. This reverts an unintended change in behaviour from the v0.13 release which made the error message inaccessible.
-
You can now use external types of various flavours - see the fine manual
-
An environment variable
UNIFFI_TESTS_DISABLE_EXTENSIONScan disable foreign language bindings when running tests. See the contributing guide for more.
- Fixed an accidental regression in v0.13.0 where errors were no longer being coerced
to the correct type via
Into. If the UDL declares a[Throws=ExampleError]function or method, the underlying implementation can now return anything that isInto<ExampleError>, matching the implicitIntobehavoir of Rust's?operator. - Fixed an accidental regression in v0.13.0 where the generated Rust scaffolding assumed
that the
HashMaptype would be in scope. It now uses fully-qualified type names in order to be more robust.
- UniFFI no longer has ffi-support as a dependency. This means it handles
panic logging on its own. If you previously enabled the
log_panicsfeature forffi-support, now you should enable it foruniffi. - The Swift bindings now explicitly generate two separate Swift modules, one for
the high-level Swift code and one for the low-level C FFI. This change is intended
to simplify distribution of the bindings via Swift packages, but brings with it
some changes to the generated file layout.
- For an interface namespace "example", we now generate:
- A bridged C module named "exampleFFI" containing the low-level C FFI,
consisting of an
exampleFFI.hfile and matchingexampleFFI.modulemapfile. The name can be customized using theffi_module_nameconfig option. - A Swift module named "example" containing the high-level Swift bindings,
which imports and uses the low-level C FFI. The name can be customized using
the
module_nameconfig option.
- A bridged C module named "exampleFFI" containing the low-level C FFI,
consisting of an
- For an interface namespace "example", we now generate:
- Python timestamps will now be in UTC and timezone-aware rather than naive.
- Kotlin exceptions names will now replace a trailing "Error" with "Exception" rather than appending the string (FooException instead of FooErrorException)
- JNA 5.7 or greater is required for Kotlin consumers
- Both python and ruby backends now handle U16 correctly.
- Error variants can now contain named fields, similar to Enum variants
- Replaced the
ViaFfitrait with theFfiConvertertrait.FfiConverteris a more flexible version ofViaFfibecause it can convert any Rust type to/from an Ffi type, rather than only Self. This allows for using UniFFI with a type defined in an external crate.
- It is now possible to use Object instances as fields in Records or Enums, to pass them as arguments,
and to return them from function and method calls. They should for the most part behave just like
a host language object, and their lifecycle is managed transparently using Rust's
Arc<T>type.- Reference cycles that include Rust objects will not be garbage collected; if you cannot avoid
creating reference cycles you may need to use Rust's
Weak<T>type to help break them. - In the Kotlin bindings, Object instances must be manually freed by calling their
destroy()method or by using their.useblock helper method. Records or Enums that contain an Object instance now also have adestroy()method and must be similarly disposed of after use.
- Reference cycles that include Rust objects will not be garbage collected; if you cannot avoid
creating reference cycles you may need to use Rust's
- Kotlin objects now implement
AutoCloseableby default; closing an object instance is equivalent to calling itsdestroy()method.
- All interface implementations must now be
Sync + Send, and Rust will give a compile-time error if they are not. This makes the[Threadsafe]annotation redundant, so it is now deprecated and will be removed in a future release. More details on the motivation for this change can be found in ADR-0004.
- Swift structs and Kotlin data classes generated from
dictionaryare now mutable by default:- Swift now uses
varinstead oflet - Kotlin now uses
varinstead ofval
- Swift now uses
- Kotlin objects can now safely have their
destroy()method or.useblock execute concurrently with other method calls. It's recommended that you not do this, but if you accidentally do so, it will now work correctly rather than triggering a panic in the underlying Rust code.
- Two new built-in datatypes have been added: the
timestamptype for representing moments in time, and thedurationtype for representing a difference between two timestamps. These mirror thestd::time::{SystemTime, Duration}types from Rust. Thanks to @npars for contributing this feature!- This is a breaking change as it may conflict with user-declared
timestampordurationtypes in existing.udlfiles.
- This is a breaking change as it may conflict with user-declared
- A new Ruby codegen backend has been added. You can now call
uniffi-bindgen -l rubyto generate a Ruby module that wraps a UniFFI Rust component. Thanks to @saks for contributing this backend!- When running
cargo testlocally, you will need a recent version of Ruby and theffigem in order to successfully execute the Ruby backend tests.
- When running
- Threadsafe Object methods can now use
self: Arc<Self>as the method receiver in the underlying Rust code, in addition to the defaultself: &Self. To do so, annotate the method with[Self=ByArc]in the.udlfile and update the corresponding Rust method signature to match. This will not change the generated foreign-language bindings in any way but may be useful for more explicit management of Object references in the Rust code.
- Kotlin: Fixed buggy codegen for optional primitive types like
i32?; on earlier versions this would generate invalid Kotlin code which would fail to compile.
- Support for non-
[Threadsafe]interfaces has been deprecated. A future release will require that all interface implementations beSync + Send, making the[Threadsafe]annotation redundant.
- Errors when parsing a
.udlfile are now marginally more useful (they're still not great, but they're better). - Generated code should now be deterministic between runs with the same input file and version of UniFFI. Previously, the generated code could depend on the iteration order of an internal hash table.
- Swift: Generated Swift Enums now conform to
Hashableby default. - Swift: There are now additional docs on how to consume the generated Swift bindings via XCode.
We did not maintain a changelog for previous releases.