Introducing Keras 3 for R

We are thrilled to introduce keras3, the next version of the Keras R
package. keras3 is a ground-up rebuild of {keras}, maintaining the
beloved features of the original while refining and simplifying the API
based on valuable insights gathered over the past few years.

Keras provides a complete toolkit for building deep learning models in
R—it’s never been easier to build, train, evaluate, and deploy deep
learning models.


To install Keras 3: There, you will find guides, tutorials,
reference pages with rendered examples, and a new examples gallery. All
the reference pages and guides are also available via R’s built-in help

In a fast moving ecosystem like deep learning, creating great
documentation and wrappers once is not enough. There also need to be
workflows that ensure the documentation is up-to-date with upstream
dependencies. To accomplish this, {keras3} includes two new maintainer
features that ensure the R documentation and function wrappers will stay

  • We now take snapshots of the upstream documentation and API surface.
    With each release, all R documentation is rebased on upstream
    updates. This workflow ensures that all R documentation (guides,
    examples, vignettes, and reference pages) and R function signatures
    stay up-to-date with upstream. This snapshot-and-rebase
    functionality is implemented in a new standalone R package,
    {doctether}, which may
    be useful for R package maintainers needing to keep documentation in
    parity with dependencies.

  • All examples and vignettes can now be evaluated and rendered during
    a package build. This ensures that no stale or broken example code
    makes it into a release. It also means all user facing example code
    now additionally serves as an extended suite of snapshot unit and
    integration tests.

    Evaluating code in vignettes and examples is still not permitted
    according to CRAN restrictions. We work around the CRAN restriction
    by adding additional package build steps that pre-render

Combined, these two features will make it substantially easier for Keras
in R to maintain feature parity and up-to-date documentation with the
Python API to Keras.

Multi-backend support

Soon after its launch in 2015, Keras featured support for most popular
deep learning frameworks: TensorFlow, Theano, MXNet, and CNTK. Over
time, the landscape shifted; Theano, MXNet, and CNTK were retired, and
TensorFlow surged in popularity. In 2021, three years ago, TensorFlow
became the premier and only supported Keras backend. Now, the landscape
has shifted again.

Keras 3 brings the return of multi-backend support. Choose a backend by

provides a comprehensive suite of operations typically needed when
operating on nd-arrays for deep learning. The Operation family
supersedes and greatly expands on the former family of backend functions
prefixed with k_ in the {keras} package.

The Ops functions let you write backend-agnostic code. They provide a
uniform API, regardless of if you’re working with TensorFlow Tensors,
Jax Arrays, Torch Tensors, Keras Symbolic Tensors, NumPy arrays, or R

The Ops functions:

  • all start with prefix op_ (e.g., op_stack())
  • all are pure functions (they produce no side-effects)
  • all use consistent 1-based indexing, and coerce doubles to integers
    as needed
  • all are safe to use with any backend (tensorflow, jax, torch, numpy)
  • all are safe to use in both eager and graph/jit/tracing modes

The Ops API includes:

  • The entirety of the NumPy API (numpy.*)
  • The TensorFlow NN API (tf.nn.*)
  • Common linear algebra functions (A subset of scipy.linalg.*)
  • A subfamily of image transformers
  • A comprehensive set of loss functions
  • And more!

Ingest tabular data with layer_feature_space()

keras3 provides a new set of functions for building models that ingest
tabular data: layer_feature_space() and a family of feature
transformer functions (prefix, feature_) for building keras models
that can work with tabular data, either as inputs to a keras model, or
as preprocessing steps in a data loading pipeline (e.g., a

See the reference
and an
example usage in a full end-to-end

to learn more.

New Subclassing API

The subclassing API has been refined and extended to more Keras
Define subclasses simply by calling: Layer(), Loss(), Metric(),
Callback(), Constraint(), Model(), and LearningRateSchedule().
Defining {R6} proxy classes is no longer necessary.

Additionally the documentation page for each of the subclassing
functions now contains a comprehensive listing of all the available
attributes and methods for that type. Check out
?Layer to see what’s

Saving and Export

Keras 3 brings a new model serialization and export API. It is now much
simpler to save and restore models, and also, to export them for

  • save_model()/load_model():
    A new high-level file format (extension: .keras) for saving and
    restoring a full model.

    The file format is backend-agnostic. This means that you can convert
    trained models between backends, simply by saving with one backend,
    and then loading with another. For example, train a model using Jax,
    and then convert to Tensorflow for export.

  • export_savedmodel():
    Export just the forward pass of a model as a compiled artifact for
    inference with TF
    or (soon)
    Posit Connect. This
    is the easiest way to deploy a Keras model for efficient and
    concurrent inference serving, all without any R or Python runtime

  • Lower level entry points:

    • save_model_weights() / load_model_weights():
      save just the weights as .h5 files.
    • save_model_config() / load_model_config():
      save just the model architecture as a json file.
  • register_keras_serializable():
    Register custom objects to enable them to be serialized and

  • serialize_keras_object() / deserialize_keras_object():
    Convert any Keras object to an R list of simple types that is safe
    to convert to JSON or rds.

  • See the new Serialization and Saving

    for more details and examples.

New random family

A new family of random tensor
Like the Ops family, these work with all backends. Additionally, all the
RNG-using methods have support for stateless usage when you pass in a
seed generator. This enables tracing and compilation by frameworks that
have special support for stateless, pure, functions, like Jax. See
for example usage.

Other additions:

  • New shape()
    function, one-stop utility for working with tensor shapes in all

  • New and improved print(model) and plot(model) method. See some
    examples of output in the Functional API

  • All new fit() progress bar and live metrics viewer output,
    including new dark-mode support in the RStudio IDE.

  • New config
    a curated set of functions for getting and setting Keras global

  • All of the other function families have expanded with new members:

Migrating from {keras} to {keras3}

{keras3} is ultimately a preview of the future {keras} package.

If you’re writing new code today, you can start using {keras3} right

If you have legacy code that uses {keras}, you are encouraged to
update the code for {keras3}. For many high-level API functions, such
as layer_dense(), fit(), and keras_model(), minimal to no changes
are required. However there is a long tail of small changes that you
might need to make when updating code that made use of the lower-level
Keras API. Some of those are documented here:

If you’re running into issues or have questions about updating, don’t
hesitate to ask on or

The {keras} and {keras3} packages will coexist while the community
transitions. During the transition, {keras} will continue to receive
patch updates for compatibility with Keras v2, which continues to be
published to PyPi under the package name tf-keras.

{keras3} is intended as a transition package name. In a future update,
the {keras} package will begin emitting a package startup message,
announcing a deprecation period. After a notice period in the {keras}
package, {keras3} will be renamed to {keras}. At that time {keras}
(v2) will no longer be supported, and {keras3} will be an alias for


In summary, {keras3} is a robust update to the Keras R package,
incorporating new features while preserving the ease of use and
functionality of the original. The new multi-backend support,
comprehensive suite of Ops functions, refined model serialization API,
and updated documentation workflows enable users to easily take
advantage of the latest developments in the deep learning community.

Whether you are a seasoned Keras user or just starting your deep
learning journey, Keras 3 provides the tools and flexibility to build,
train, and deploy models with ease and confidence. As we transition from
Keras 2 to Keras 3, we are committed to supporting the community and
ensuring a smooth migration. We invite you to explore the new features,
check out the updated documentation, and join the conversation on our
GitHub discussions page. Welcome to the next chapter of deep learning in
R with Keras 3!