Softpedia >Windows >Programming >Coding languages / Compilers >Erlang OTP >  Changelog

Erlang OTP Changelog

What's new in Erlang OTP 27.0 RC 3

Apr 18, 2024
  • The support for multiple trace sessions is now documented and ready for use.

New in Erlang OTP 27.0 RC 2 (Mar 21, 2024)

  • Highlights for RC2:
  • There is a new module json for encoding and decoding JSON.
  • Both encoding and decoding can be customized. Decoding can be done in a SAX-like fashion and handle multiple documents and streams of data.
  • The new json module is used by the jer (JSON Encoding Rules) for ASN.1 for encoding and decoding JSON. Thus, there is no longer any need to supply an external JSON library.
  • Other notable changes in RC2:
  • The existing experimental support for archive files will be changed in a future release. The support for having an archive in an escript will remain, but the support for using archives in a release will either become more limited or completely removed.
  • As of Erlang/OTP 27, the function code:lib_dir/2, the -code_path_choice flag, and using erl_prim_loader for reading members of an archive are deprecated.
  • To remain compatible with future version of Erlang/OTP escript scripts that need to retrieve data files from its archive should use escript:extract/2 instead of erl_prim_loader and code:lib_dir/2.
  • The order in which the compiler looks up options has changed.
  • When there is a conflict in the compiler options given in the -compile() attribute and options given to the compiler, the options given in the -compile() attribute overrides the option given to the compiler, which in turn overrides options given in the ERL_COMPILER_OPTIONS environment variable.

New in Erlang OTP 27.0 RC 1 (Feb 14, 2024)

  • New language features:
  • Triple-Quoted Strings has been implemented as per EEP 64 to allow a string to encompass a complete paragraph.
  • Adjacent string literals without intervening white space is now a syntax error, to avoid possible confusion with triple-quoted strings.
  • Sigils on string literals (both ordinary and triple-quoted) have been implemented as per EEP 66. For example, ~"Björn" or ~b"Björn" are now equivalent to <<"Björn"/utf8>>.
  • Compiler and JIT improvements:
  • The compiler will now merge consecutive updates of the same record.
  • Safe destructive update of tuples has been implemented in the compiler and runtime system. This allows the VM to update tuples in-place when it is safe to do so, thus improving performance by doing less copying but also by producing less garbage.
  • The maybe expression is now enabled by default, eliminating the need for enabling the maybe_expr feature.
  • Native coverage support has been implemented in the JIT. It will automatically be used by the cover tool to reduce the execution overhead when running cover-compiled code. There are also new APIs to support native coverage without using the cover tool.
  • The compiler will now raise a warning when updating record/map literals to catch a common mistake. For example, the compiler will now emit a warning for #r{a=1}#r{b=2}.
  • ERTS:
  • The erl command now supports the -S flag, which is similar to the -run flag, but with some of the rough edges filed off.
  • By default, escripts will now be compiled instead of interpreted. That means that the compiler application must be installed.
  • The default process limit has been raised to 1048576 processes.
  • The erlang:system_monitor/2 functionality is now able to monitor long message queues in the system.
  • The obsolete and undocumented support for opening a port to an external resource by passing an atom (or a string) as first argument to open_port(), implemented by the vanilla driver, has been removed. This feature has been scheduled for removal in OTP 27 since the release of OTP 26.
  • The pid field has been removed from erlang:fun_info/1,2.
  • Multiple trace sessions are now supported.
  • STDLIB:
  • Several new functions that accept funs have been added to module timer.
  • The functions is_equal/2, map/2, and filtermap/2 have been added to the modules sets, ordsets, and gb_sets.
  • There are new efficient ets traversal functions with guaranteed atomicity. For example, ets:next/2 followed by ets:lookup/2 can now be replaced with ets:next_lookup/1.
  • The new function ets:update_element/4 is similar to ets:update_element/3, but takes a default tuple as the fourth argument, which will be inserted if no previous record with that key exists.
  • binary:replace/3,4 now supports using a fun for supplying the replacement binary.
  • The new function proc_lib:set_label/1 can be used to add a descriptive term to any process that does not have a registered name. The name will be shown by tools such as c:i/0 and observer, and it will be included in crash reports produced by processes using gen_server, gen_statem, gen_event, and gen_fsm.
  • Added functions to retrieve the next higher or lower key/element from gb_trees and gb_sets, as well as returning iterators that start at given keys/elements.
  • common_test:
  • Calls to ct:capture_start/0 and ct:capture_stop/0 are now synchronous to ensure that all output is captured.
  • The default CSS will now include a basic dark mode handling if it is preferred by the browser.
  • crypto:
  • The functions crypto_dyn_iv_init/3 and crypto_dyn_iv_update/3 that were marked as deprecated in Erlang/OTP 25 have been removed.
  • dialyzer:
  • The --gui option for Dialyzer has been removed.
  • ssl:
  • The ssl client can negotiate and handle certificate status request (OCSP stapling support on the client side).
  • tools:
  • There is a new tool tprof, which combines the functionality of eprof and cprof under one interface. It also adds heap profiling.
  • xmerl:
  • As an alternative to xmerl_xml, a new export module xmerl_xml_indent that provides out-of-the box indented output has been added.

New in Erlang OTP 26.2 (Dec 13, 2023)

  • Highlights:
  • process_info/2 now supports lookup of values for specific keys in the process dictionary.
  • Potential incompatibilities:
  • common_test now returns an error when a suite with a badly defined group is executed.

New in Erlang OTP 26.1 (Sep 20, 2023)

  • Erlang/OTP 26.1 is the first maintenance patch package for OTP 26, with mostly bug fixes as well as improvements.

New in Erlang OTP 26.0 RC 3 (Apr 12, 2023)

  • Erlang/OTP 26.0-rc3 is the third and last release candidate before the OTP 26.0 release. The release candidate 3 fixes some bugs found in the first two release candidates.
  • The intention with this release is to get feedback from our users. All feedback is welcome, even if it is only to say that it works for you. We encourage users to try it out and give us feedback either by creating an issue here https://github.com/erlang/otp/issues or by posting to Erlangforums.
  • All artifacts for the release can be downloaded from the Erlang/OTP Github release and you can view the new documentation at https://erlang.org/documentation/doc-14.0-rc3/doc/. You can also install the latest release using kerl like this: kerl build 26.0-rc3 26.0-rc3.

New in Erlang OTP 26.0 RC 2 (Mar 22, 2023)

  • Parsetools:
  • Leex has been extended with optional column number support.
  • Stdlib:
  • The family of enumeration functions in module lists has been extended with enumerate/3 that allows a step value to be supplied.
  • Update Unicode to version 15.0.0.
  • proc_lib:start*/* has become synchronous when the started process fails. This requires that a failing process use a new function proc_lib:init_fail/2,3, or exits, to indicate failure. All OTP behaviours have been fixed to do this.
  • Dialyzer:
  • Added the new built-in type dynamic() introduced in EEP 61, PR introducing EEP 61 improving support for gradual type checkers.
  • SSL:
  • Change the client default verify option to verify_peer. Note that this makes it mandatory to also supply trusted CA certificates or explicitly set verify to verify_none. This also applies when using the so called anonymous test cipher suites defined in TLS versions pre TLS-1.3.

New in Erlang OTP 25.3 (Mar 8, 2023)

  • Support for fully asynchronous distributed signaling where send operations never block. This functionality is by default disabled and can be enabled per process. For more information see the documentation of process_flag(async_dist, Bool).

New in Erlang OTP 26.0 RC 1 (Feb 15, 2023)

  • The Shell:
  • There are a lot of new features and improvements in the Erlang shell:
  • Auto-complete of variables, record names, record fields names, map keys, function parameter types and filenames.
  • Open external editor in the shell to edit the current expression.
  • Defining records (with types), functions, specs and types in the shell.
  • New terminal:
  • The TTY/terminal subsystem has been rewritten. Windows users will notice that erl.exe has the same functionality as a normal Unix shell and that werl.exe is just a symlink to erl.exe. This makes the Windows Erlang terminal experience identical to that of Unix.
  • Compiler and JIT optimizations: #
  • Creation and matching of binaries with segments of fixed sizes have been optimized.
  • Creation and matching of UTF-8 segments have been optimized.
  • Appending to binaries has been optimized.
  • The compiler and JIT now generate better code for creation of small maps where all keys are literals known at compile time.
  • Thanks to the optimizations above the performance of the base64 module has been significantly improved. For example, on an x86_64 system with the JIT both encode and decode are almost three times faster than in Erlang/OTP 25.
  • Maps:
  • Map comprehensions as suggested in EEP 58 has now been implemented.
  • Some map operations have been optimized by changing the internal sort order of atom keys. This changes the (undocumented) order of how atom keys in small maps are printed and returned by maps:to_list/1 and maps:next/1. The new order is unpredictable and may change between different invocations of the Erlang VM.
  • Introducing the new function maps:iterator/2 for creating an interator that return the map elements in a deterministic order. There are also new modifiers k and K for the format string in io:format() to support printing map elements ordered.
  • Dialyzer:
  • Dialyzer has a new incremental mode that be invoked by giving the --incremental option when running Dialyzer. This new incremental mode is likely to become the default in a future release.
  • Misc ERTS, Stdlib, Kernel, Compiler:
  • Multi time warp mode is now enabled by default. This assumes that all code executing on the system is time warp safe.
  • Support for UTF-8 atoms and strings in the NIF interface including new functions enif_make_new_atom, enif_make_new_atom_len and enif_get_string_length.
  • The BIFs min/2 and max/2 are now allowed to be used in guards and match specs.
  • Improved the selective receive optimization, which can now be enabled for references returned from other functions. This greatly improves the performance of gen_server:send_request/3, gen_server:wait_response/2, and similar functions.
  • New trace feature call_memory. Similar to call_time tracing, but instead of measure accumulated time in traced functions it measures accumulated heap space consumed by traced functions. It can be used to compare how much different functions are contributing to garbage collection being triggered.
  • It is no longer necessary to enable a feature in the runtime system in order to load modules that are using it. It is sufficient to enable the feature in the compiler when compiling it.
  • Inet:setopts/2 has got 3 new options: reuseport, reuseport_lb and exclusiveaddruse.
  • Fix so that -fno-omit-frame-pointer is applied to all of the Erlang VM when using the JIT so that tools, such as perf, can crawl the process stacks.
  • In the lists module, the zip family of functions now takes options to allow handling lists of different lengths.
  • Added the zip:zip_get_crc32/2 function to retrieve the CRC32 checksum from an opened ZIP archive. gen_server optimized by caching callback functions
  • The modules Erlang DNS resolver inet_res and helper modules have been updated for RFC6891; to handle OPT RR with DNSSEC OK (DO) bit.
  • Introduced application:get_supervisor/1.
  • Cache OTP boot code paths, to limit how many folders that are being accessed during a module lookup. Can be disabled with -cache_boot_path false.
  • SSL:
  • Support for Kernel TLS (kTLS), has been added to the SSL application, for TLS distribution (-proto_dist inet_tls), the SSL option {ktls, true}.
  • Improved error checking and handling of ssl options.
  • Mitigate memory usage from large certificate chains by lowering the maximum handshake size. This should not effect the common cases, if needed it can be configured to a higher value.
  • For security reasons the SHA1 and DSA algorithms are no longer among the default values.
  • Add encoding and decoding of use_srtp hello extension to facilitate for DTLS users to implement SRTP functionality.

New in Erlang OTP 25.2 (Dec 14, 2022)

  • Potential incompatibilities:
  • The inet:setopts/2 {reuseaddr, true} option will now be ignored on Windows unless the socket is an UDP socket. For more information see the documentation of the reuseaddr option part of the documentation of inet:setopts/2. Prior to OTP 25 the {reuseaddr, true} option was ignored for all sockets on Windows, but as of OTP 25.0 this was changed so that it was not ignored for any sockets.

New in Erlang OTP 25.1 (Sep 21, 2022)

  • Crypto:
  • Crypto is now considered to be usable with the OpenSSL 3.0 cryptolib for production code. ENGINE and FIPS are not yet fully functional.
  • Changed the behaviour of the engine load/unload functions
  • Ssl:
  • A vulnerability has been discovered and corrected. It is registered as CVE-2022-37026 “Client Authentication Bypass”. Corrections have been released on the supported tracks with patches 23.3.4.15, 24.3.4.2, and 25.0.2. The vulnerability might also exist in older OTP versions. We recommend that impacted users upgrade to one of these versions or later on the respective tracks. OTP 25.1 would be an even better choice. Impacted are those who are running an ssl/tls/dtls server using the ssl application either directly or indirectly via other applications. For example via inets (httpd), cowboy, etc. Note that the vulnerability only affects servers that request client certification, that is sets the option {verify, verify_peer}.

New in Erlang OTP 25.0 (May 19, 2022)

  • Stdlib:
  • New function filelib:ensure_path/1 will ensure that all directories for the given path exists
  • New functions groups_from_list/2 and groups_from_list/3 in the maps module
  • New functions uniq/1 uniq/2 in the lists module
  • New PRNG added to the rand module, for fast pseudo-random numers.
  • Compiler, kernel, stdlib, syntax_tools:
  • Added support for selectable features as described in EEP-60. Features can be enabled/disabled during compilation with options (ordinary and +term) to erlc as well as with directives in the file. Similar options can be used to erl for enabling/disabling features allowed at runtime. The new maybe expression EEP-49 is fully supported as the feature maybe_expr.
  • Erts & JIT
  • The JIT now works for 64-bit ARM processors.
  • The JIT now does type-based optimizations based on type information in the BEAM files.
  • Improved the JIT’s support for external tools like perf and gdb, allowing them to show line numbers and even the original Erlang source code when that can be found.
  • Erts, stdlib, kernel:
  • Users can now configure ETS tables with the {write_concurrency, auto} option. This option forces tables to automatically change the number of locks that are used at run-time depending on how much concurrency is detected. The {decentralized_counters, true} option is enabled by default when {write_concurrency, auto} is active.
  • Benchmark results comparing this option with the other ETS optimization options are available here: benchmarks.
  • To enable more optimizations, BEAM files compiled with OTP 21 and earlier cannot be loaded in OTP 25.
  • The signal queue of a process with the process flag message_queue_data=off_heap has been optimized to allow parallel reception of signals from multiple processes. This can improve performance when many processes are sending in parallel to one process. See benchmark.
  • The Erlang installation directory is now relocatable on the file system given that the paths in the installation’s RELEASES file are paths that are relative to the installations root directory.
  • A new option called short has been added to the functions erlang:float_to_list/2 and erlang:float_to_binary/2. This option creates the shortest correctly rounded string representation of the given float that can be converted back to the same float again.
  • Introduction of quote/1 and unquote/1 functions in the uri_string module - a replacement for the deprecated functions http_uri:encode and http_uri:decode.
  • The new module peer supersedes the slave module. The slave module is now deprecated and will be removed in OTP 27.
  • Global will now by default prevent overlapping partitions due to network issues. This is done by actively disconnecting from nodes that reports that they have lost connections to other nodes. This will cause fully connected partitions to form instead of leaving the network in a state with overlapping partitions.
  • It is possible to turn off the new behavior by setting the the kernel configuration parameter prevent_overlapping_partitions to false. Doing this will retain the same behavior as in OTP 24 and earlier.
  • The format_status/2 callback for gen_server, gen_statem and gen_event has been deprecated in favor of the new format_status/1 callback.
  • The new callback adds the possibility to limit and change many more things than the just the state.
  • The timer module has been modernized and made more efficient, which makes the timer server less susceptible to being overloaded. The timer:sleep/1 function now accepts an arbitrarily large integer.
  • Compiler:
  • The maybe ... end construction as proposed in EEP-49 has been implemented. It can simplify complex code where otherwise deeply nested cases would have to be used.
  • To enable maybe, give the option {enable_feature,maybe_expr} to the compiler. The exact option to use will change in a coming release candidate and then it will also be possible to use from inside the module being compiled.
  • When a record matching or record update fails, a {badrecord, ExpectedRecordTag} exception used to be raised. In this release, the exception has been changed to {badrecord, ActualValue}, where ActualValue is the value that was found instead of the expected record.
  • Add compile attribute -nifs() to empower compiler and loader with information about which functions may be overridden as NIFs by erlang:load_nif/2.
  • Improved and more detailed error messages when binary construction with the binary syntax fails. This applies both for error messages in the shell and for erl_error:format_exception/3,4.
  • Change format of feature options and directives for better consistency. Options to erlc and the -compile(..) directive now has the format {feature, feature-name, enable | disable}. The -feature(..) now has the format -feature(feature-name, enable | disable).
  • Crypto:
  • Add crypto:hash_equals/2 which is a constant time comparision of hashvalues.
  • Ssl:
  • Introducing a new (still experimental) option {certs_keys,[cert_key_conf()]}. With this a list of a certificates with their associated key may be used to authenticate the client or the server. The certificate key pair that is considered best and matches negotiated parameters for the connection will be selected.
  • Public_key:
  • Functions for retrieving OS provided CA-certs added.
  • Dialyzer:
  • Optimize operations in the erl_types module. Parallelize the Dialyzer pass remote.
  • Added the missing_return and extra_return options to raise warnings when specifications differ from inferred types. These are similar to, but not quite as verbose as overspecs and underspecs.
  • Dialyzer now better understands the types for min/2, max/2, and erlang:raise/3. Because of that, Dialyzer can potentially generate new warnings. In particular, functions that use erlang:raise/3 could now need a spec with a no_return() return type to avoid an unwanted warning.
  • Misc:
  • A new DEVELOPMENT HOWTO guide has been added that describes how to build and test Erlang/OTP when fixing bugs or developing new functionality.
  • Testing has been added to the Github actions run for each opened PR so that more bugs are caught earlier when bug fixes and new features are proposed.

New in Erlang OTP 25.0 RC 3 (Apr 13, 2022)

  • Highlights rc3:
  • Compiler:
  • Change format of feature options and directives for better consistency. Options to erlc and the -compile(..) directive now has the format {feature, feature-name, enable | disable}. The -feature(..) now has the format -feature(feature-name, enable | disable).
  • Ssl:
  • Introducing a new (still experimental) option {certs_keys,[cert_key_conf()]}. With this a list of a certificates with their associated key may be used to authenticate the client or the server. The certificate key pair that is considered best and matches negotiated parameters for the connection will be selected.

New in Erlang OTP 25.0 RC 2 (Mar 24, 2022)

  • Stdlib:
  • New function filelib:ensure_path/1 will ensure that all directories for the given path exists
  • New functions groups_from_list/2 and groups_from_list/3 in the maps module
  • New functions uniq/1 uniq/2 in the lists module
  • Compiler, kernel, stdlib, syntax_tools:
  • Added support for selectable features as described in EEP-60. Features can be enabled/disabled during compilation with options (ordinary and +term) to erlc as well as with directives in the file. Similar options can be used to erl for enabling/disabling features allowed at runtime. The new maybe expression EEP-49 is fully supported as the feature maybe_expr.

New in Erlang OTP 24.3 (Mar 10, 2022)

  • Highlights:
  • Crypto: The crypto app in OTP can now be compiled, linked and used with the new OpenSSL 3.0 cryptolib. It has not yet been extensively tested, so only recommended for experiments and alpha testing in this release. There are not yet any guaranties that it works, not even together with other OTP applications like for example SSL and SSH, although there are no known errors.
  • Erts, kernel: Support for using socket:sockaddr_in() and socket:sockaddr_in6() when using gen_sctp, gen_tcp and gen_udp, will make it possible to use Link Local IPv6 addresses.
  • Erts, kernel: By default global does not take any actions to restore a fully connected network when connections are lost due to network issues. This is problematic for all applications expecting a fully connected network to be provided, such as for example mnesia, but also for global itself. A network of overlapping partitions might cause the internal state of global to become inconsistent. Such an inconsistency can remain even after such partitions have been brought together to form a fully connected network again. The effect on other applications that expects that a fully connected network is maintained may vary, but they might misbehave in very subtle hard to detect ways during such a partitioning. In order to prevent such issues, we have introduced a prevent overlapping partitions fix which can be enabled using the prevent_overlapping_partitions kernel(6) parameter. As of OTP 25 this fix will become enabled by default

New in Erlang OTP 25.0 RC 1 (Feb 16, 2022)

  • Highlights:
  • Erts & jit:
  • The JIT now works for 64-bit ARM processors.
  • The JIT now does type-based optimizations based on type information in the BEAM files.
  • Improved the JIT’s support for external tools like perf and gdb, allowing them to show line numbers and even the original Erlang source code when that can be found.
  • Erts, stdlib, kernel:
  • Users can now configure ETS tables with the {write_concurrency, auto} option. This option forces tables to automatically change the number of locks that are used at run-time depending on how much concurrency is detected. The {decentralized_counters, true} option is enabled by default when {write_concurrency, auto} is active.
  • Benchmark results comparing this option with the other ETS optimization options are available here: benchmarks.
  • To enable more optimizations, BEAM files compiled with OTP 21 and earlier cannot be loaded in OTP 25.
  • The signal queue of a process with the process flag message_queue_data=off_heap has been optimized to allow parallel reception of signals from multiple processes. This can improve performance when many processes are sending in parallel to one process. See benchmark.
  • The Erlang installation directory is now relocatable on the file system given that the paths in the installation’s RELEASES file are paths that are relative to the installations root directory.
  • A new option called short has been added to the functions erlang:float_to_list/2 and erlang:float_to_binary/2. This option creates the shortest correctly rounded string representation of the given float that can be converted back to the same float again.
  • Introduction of quote/1 and unquote/1 functions in the uri_string module - a replacement for the deprecated functions http_uri:encode and http_uri:decode.
  • The new module peer supersedes the slave module. The slave module is now deprecated and will be removed in OTP 27.
  • global will now by default prevent overlapping partitions due to network issues. This is done by actively disconnecting from nodes that reports that they have lost connections to other nodes. This will cause fully connected partitions to form instead of leaving the network in a state with overlapping partitions.
  • It is possible to turn off the new behavior by setting the the kernel configuration parameter prevent_overlapping_partitions to false. Doing this will retain the same behavior as in OTP 24 and earlier.
  • The format_status/2 callback for gen_server, gen_statem and gen_event has been deprecated in favor of the new format_status/1 callback.
  • The new callback adds the possibility to limit and change many more things than the just the state.
  • The timer module has been modernized and made more efficient, which makes the timer server less susceptible to being overloaded. The timer:sleep/1 function now accepts an arbitrarily large integer.
  • Compiler:
  • The maybe ... end construction as proposed in EEP-49 has been implemented. It can simplify complex code where otherwise deeply nested cases would have to be used.
  • To enable maybe, give the option {enable,maybe_expr} to the compiler. The exact option to use will change in a coming release candidate and then it will also be possible to use from inside the module being compiled.
  • When a record matching or record update fails, a {badrecord, ExpectedRecordTag} exception used to be raised. In this release, the exception has been changed to {badrecord, ActualValue}, where ActualValue is the value that was found instead of the expected record.
  • Add compile attribute -nifs() to empower compiler and loader with information about which functions may be overridden as NIFs by erlang:load_nif/2.
  • Improved and more detailed error messages when binary construction with the binary syntax fails. This applies both for error messages in the shell and for erl_error:format_exception/3,4.
  • Crypto:
  • Add crypto:hash_equals/2 which is a constant time comparision of hashvalues.
  • Dialyzer:
  • Optimize operations in the erl_types module. Parallelize the Dialyzer pass remote.
  • Added the missing_return and extra_return options to raise warnings when specifications differ from inferred types. These are similar to, but not quite as verbose as overspecs and underspecs.
  • Dialyzer now better understands the types for min/2, max/2, and erlang:raise/3. Because of that, Dialyzer can potentially generate new warnings. In particular, functions that use erlang:raise/3 could now need a spec with a no_return() return type to avoid an unwanted warning.
  • Misc:
  • A new DEVELOPMENT HOWTO guide has been added that describes how to build and test Erlang/OTP when fixing bugs or developing new functionality.
  • Testing has been added to the Github actions run for each opened PR so that more bugs are caught earlier when bug fixes and new features are proposed.

New in Erlang OTP 24.2 (Dec 15, 2021)

  • Erlang/OTP 24.2 is the second maintenance patch release for OTP 24, with mostly bug fixes as well as a few improvements.

New in Erlang OTP 24.1 (Oct 5, 2021)

  • OTP:
  • The Efficiency Guide has been extended with a chapter about maps.
  • Stdlib:
  • Most output functions in the io module now print extra error information when provided with invalid arguments.
  • The functions are: io:format, io:fwrite, io:put_chars, io:nl and io:write.
  • Erts:
  • init:stop() no longer unloads loaded code before terminating the runtime system. On systems with slow CPUs (such as Raspberry PI Zero), that can significantly speed up termination of the runtime system.

New in Erlang OTP 24.0 (May 13, 2021)

  • Erlang/OTP 24 is a new major release with new features, improvements as well as a few incompatibilities.
  • Below are some of the highlights of the release:
  • HIGHLIGHTS:
  • compiler:
  • The compiler will now inline funs that are used only once immediately after their definition.
  • Compiler warnings and errors now include column numbers in addition to line numbers.
  • Variables bound between the keywords 'try' and 'of' can now be used in the clauses following the 'of' keyword
  • (that is, in the success case when no exception was raised).
  • Generators in list and binary comprehensions will now
  • raise a {bad_generator,Generator} exception if the
  • generator has an incorrect type
  • Similarly, when a
  • filter does not evaluate to a boolean, a
  • {bad_filter,Filter} exception will be raised.
  • Warnings for expressions whose result was ignored that could be suppressed by
  • using the anonymous variable '_' can now be suppressed with a variable beginning with '_'.
  • Selective receive optimization will now be applied much
  • more often.
  • The new recv_opt_info compile flag can be used to print
  • diagnostics relating to this optimization.
  • You can read more about the selective receive
  • optimization in the Efficiency Guide.
  • erts, kernel, stdlib:
  • hex encoding and decoding functions added in the binary module
  • The BeamAsm JIT-compiler has been added to Erlang/OTP and will give a significant performance boost for many applications.
  • The JIT-compiler is enabled by default on most x86 64-bit platforms that have a C++ compiler that can compile C++17.
  • To verify that a JIT enabled emulator is running you can use erlang:system_info(emu_flavor).
  • A compatibility adaptor for gen_tcp to use the new socket API has been implemented (gen_tcp_socket).
  • Extended error information for failing BIF calls as proposed in EEP 54 has been implemented.
  • Process aliases as outlined by EEP 53 has been introduced.
  • Implementation of EEP 56 in supervisor. It adds the concept of significant children as well as the auto_shutdown supervisor flag. See the supervisor manual page for more information.
  • ftp:
  • Add support for FTPES (explicit FTP over TLS).
  • ssl:
  • Make TLS handshakes in Erlang distribution concurrent.
  • TLS connections now support EdDSA certificates.
  • wx:
  • The application has been completely rewritten in order
  • to use wxWidgets version 3 as its base.
  • Added support for wxWebView.
  • edoc:
  • EDoc is now capable of emitting EEP-48 doc chunks. This means that, with some
  • configuration, community projects can now provide documentation for shell_docs
  • the same way that OTP libraries did since OTP 23.0.

New in Erlang OTP 23.3 (Mar 24, 2021)

  • Fixed Bugs and Malfunctions:
  • OTP-17164 Application(s): otp
  • Related Id(s): ERL-845, PR-2613
  • Correct documentation of specifications of remote functions.

New in Erlang OTP 23.2 (Dec 16, 2020)

  • A few of the changes and highlights are
  • SSL:
  • Handle extraneous certs in certificate chains as well as chains that are incomplete but can be reconstructed or unordered chains. The cert and certfile options will now accept a list of certificates so that the user may specify the chain explicitly.
  • Potential incompatibility
  • stdlib
  • Improved the API and documentation of the uri_string module. Added a new chapter to the Users Guide about Uniform Resource Identifiers and their handling with the new API. Added two new API functions: uri_string:allowed_characters/0 and uri_string:percent_decode/1.
  • This change has been marked as potentially incompatible as uri_string:normalize/2 used to decode percent-encoded character triplets that corresponded to characters not in the reserved set. After this change, uri_string:normalize/2 will only decode those percent-encoded triplets that correspond to characters in the unreserved set (ALPHA / DIGIT / "-" / "." / "_" / "~").

New in Erlang OTP 23.1 (Sep 24, 2020)

  • Vulnerability fix:
  • A vulnerability in the httpd module (inets application) regarding directory traversal that was introduced in OTP 22.3.1 and corrected in OTP 22.3.4.6. It was also introduced in OTP 23.0 and corrected in OTP 23.1 The vulnerability is registered as CVE-2020-25623.
  • The vulnerability is only exposed if the http server (httpd) in the inets application is used. The vulnerability makes it possible to read arbitrary files which the Erlang system has read access to with for example a specially prepared http request.
  • General build issues:
  • Adjust /bin/sh to /system/bin/sh in scripts when installing on Android.
  • Changes in build system to make it build for macOS 11.0 with Apple Silicon. Also corrected execution of match specs to work on Apple Silicon.

New in Erlang OTP 23.0 RC 2 (May 13, 2020)

  • Potential Incompatibilities:
  • SSL:
  • Support for SSL 3.0 is completely removed.
  • TLS 1.3 is added to the list of default supported versions.
  • erl_interface: Removed the deprecated parts of erl_interface
  • (erl_interface.h and essentially all C functions with prefix erl_).
  • The deprecated erlang:get_stacktrace/0 BIF now returns an empty list instead of a stacktrace.
  • erlang:get_stacktrace/0 is scheduled for removal in OTP 24.
  • Highlights (rc2):
  • ssh:
  • OpenSSH 6.5 introduced a new file representation of keys called openssh-key-v1. This is now supported with the exception of handling encrypted keys.
  • Algorithm configuration could now be done in a .config file.
  • This is useful for example to enable an algorithm that is disabled by default without need to change the code.
  • ssl:
  • Support for the middlebox compatibility mode makes the TLS 1.3 handshake look more like a TLS 1.2 handshake and increases the chance of successfully establishing TLS 1.3 connections through legacy middleboxes.
  • Add support for key exchange with Edward curves and PSS-RSA padding in signature verification
  • The possibility to run Erlang distribution without relying on EPMD has been extended. To achieve this a couple of new options to the inet distribution has been added.
  • -dist_listen false Setup the distribution channel, but do not listen for incoming connection.
  • -erl_epmd_port Port Configure a default port that the built-in EPMD client should return.
  • A first EXPERIMENTAL socket backend to gen_tcp and inet has been implemented. gen_udp and gen_sctp will follow.
  • Putting {inet_backend, socket} as first option to listen() or connect() makes it easy to try this for existing code

New in Erlang OTP 22.1 (Dec 10, 2019)

  • Potential Incompatibilities
  • Mnesia: Transactions with sticky locks could with async_asym transactions be committed in the wrong order, since asym transactions are spawned on the remote nodes. To fix this bug the communication protocol between mnesia nodes had to be updated, thus mnesia will no longer be able to connect to nodes earlier than mnesia-4.14 ,first realeased in OTP-19.0.
  • Stdlib: Debugging of time-outs in gen_statem has been improved. Starting a time-out is now logged in sys:log and sys:trace. Running time-outs are visible in server crash logs, and with sys:get_status. Due to this system events {start_timer, Action, State} and {insert_timout, Event, State} have been added, which may surprise tools that rely on the format of these events. New features: The EventContent of a running time-out can be updated with {TimeoutType, update, NewEventContent}. Running time-outs can be cancelled with {TimeoutType, cancel} which is more readable than using Time = infinity.{rel, Name, Vsn, RelApps, Opts}.
  • Highlights
  • Compiler:
  • Erlc can now automatically use a compile server to avoid starting an Erlang system for each file to be compiled in a multi-file project. See the documentation for how to enable it.
  • Standard libraries:
  • SSL: Basic support for TLS 1.3 Client for experimental use. For more information see the Standards Compliance chapter of the User's Guide.
  • Crypto: The Message Authentication Codes (MAC) CMAC, HMAC and Poly1305 are unified into common functions in the New Crypto API. See the manual for CRYPTO. cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

New in Erlang OTP 22.0 (May 14, 2019)

  • Potential Incompatibilities:
  • gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
  • reltool: A new element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
  • All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
  • The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
  • VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.
  • Erts:
  • Support for Erlang Distribution protocol to split the payload of large signals into several fragments.
  • ETS option write_concurrency now also effects and improves scalability of ordered_set tables.
  • The length/1 BIF used to calculate the length of the list in one go without yielding, even if the list was very long. Now it yields when called with long lists.
  • A new (still experimental) module socket is introduced. It is implemented as a NIF and the idea is that it shall be as "close as possible" to the OS level socket interface.
  • Added the NIF function enif_term_type, which helps avoid long sequences of enif_is_xyz by returning the type of the given term. This is especially helpful for NIFs that serialize terms, such as JSON encoders, where it can improve both performance and readability.
  • Compiler:
  • The compiler has been rewritten to internally use an intermediate representation based on Static Single Assignment (SSA). The new intermediate representation makes more optimizations possible.
  • The binary matching optimizations are now applicable in many more circumstances than before.
  • Type optimizations are now applied across local function calls, and will remove a lot more redundant type tests than before.
  • All compiler options that can be given in the source file can now be given in the option list on the command line for erlc.
  • In OTP 22, HiPE (the native code compiler) is not fully functional. The reasons for this are new BEAM instructions for binary matching that the HiPE native code compiler does not support. If erlc is invoked with the +native option, and if any of the new binary matching instructions are used, the compiler will issue a warning and produce a BEAM file without native code.
  • Standard libraries:
  • Cover now uses the counters module instead of ets for updating counters. The new function cover:local_only/0 allows running Cover in a restricted but faster local-only mode. The increase in speed will vary depending on the type of code being cover-compiled, as an example the compiler test suite runs more than twice as fast with the new Cover.
  • A simple socket API is provided through the socket module. This is a low level API that does *not* replace gen_[tcp|udp|sctp]. It is intended to *eventually* replace the inet driver. It also provides a basic API that facilitates the implementation of other protocols than TCP, UDP and SCTP. Known issues are; No support for the Windows OS (currently), a small term leakage. This feature will be classed as experimental in OTP 22.
  • SSL: now uses the new logger API, including log levels and verbose debug logging.
  • SSL: Basic support for TLS 1.3 Server for experimental use.
  • crypto: The new hash_info/1 and cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

New in Erlang OTP 22.0 RC2 (Mar 27, 2019)

  • Potential Incompatibilities:
  • gen_* behaviours: If logging of the last N messages through sys:log/2,3 is active for the server, this log is included in the terminate report.
  • reltool: A new element, Opts, can now be included in a rel tuple in the reltool release specific configuration format: {rel, Name, Vsn, RelApps, Opts}.
  • All external pids/ports/refs created by erlang:list_to_pid and similar functions now compare equal to any other pid/port/ref with same number from that node.
  • The old legacy erl_interface library is deprecated as of OTP 22, and will be removed in OTP 23. This does not apply to the ei library.
  • VxWorks is deprecated as of OTP 22 and will be removed in OTP 23.
  • Additional highlights:
  • A simple socket API is provided through the socket module. This is a low level API that does *not* replace gen_[tcp|udp|sctp]. It is intended to *eventually* replace the inet driver. It also provides a basic API that facilitates the implementation of other protocols than TCP, UDP and SCTP. Known issues are; No support for the Windows OS (currently), a small term leakage. This feature will be classed as experimental in OTP 22.
  • ssl: Basic support for TLS 1.3 Server for experimental use.
  • In OTP 22, HiPE (the native code compiler) is not fully functional. The reasons for this are new BEAM instructions for binary matching that the HiPE native code compiler does not support. If erlc is invoked with the +native option, and if any of the new binary matching instructions are used, the compiler will issue a warning and produce a BEAM file without native code.
  • erts: Added the NIF function enif_term_type, which helps avoid long sequences of enif_is_xyz by returning the type of the given term. This is especially helpful for NIFs that serialize terms, such as JSON encoders, where it can improve both performance and readability.
  • crypto: The new hash_info/1 and cipher_info/1 functions returns maps with information about the hash or cipher in the argument.

New in Erlang OTP 21.3 (Mar 12, 2019)

  • Kernel:
  • The standard logger handler, logger_std_h, now has a new internal feature for log rotation. For full information see the documentation.
  • SSL:
  • The Reason part of the error return from the functions connect and handshake has a better and documented format. This is a potential incompatibility. See the documentation.
  • Refactoring of state handling has improved the TLS application data throughput and reduced CPU overhead
  • Code optimizations has reduced CPU load for encryption/decryption, especially for Erlang's distribution protocol over TLS
  • Now supports active N
  • Erl_interface:
  • Support for plugin of a user supplied socket implementation has been added.
  • OTP:
  • The HTML reference documentation now shows the OTP version where modules and functions were first introduced.
  • Versions of OTP older than R13B04 is not shown in the reference documentation

New in Erlang OTP 21.2 (Dec 12, 2018)

  • SSH:
  • Public key methods: ssh-ed25519 and ssh-ed448 added. Requires OpenSSL 1.1.1 or later as cryptolib under the OTP application
  • SSL:
  • Ssl now uses active n internally to boost performance. Old active once behaviour can be restored by setting a application variable.
  • ERTS, Kernel:
  • New counters and atomics modules supplies access to highly efficient operations on mutable fixed word sized variables.
  • New module persistent_term!. Lookups are in constant time! No copying the terms!
  • New pollset made to handle sockets that use {active, true} or {active, N}. Polled by a normal scheduler!
  • No more ONESHOT mechanism overhead on fds! Only on Linux and BSD

New in Erlang OTP 21.1 (Nov 11, 2018)

  • Highlights:
  • SSH:
  • The cipher '[email protected]' is now supported if OpenSSL 1.1.1 or higher is used as cryptolib.
  • The key exchange methods '[email protected]', 'curve25519-sha256' and 'curve448-sha512' are implemented. They all depends on that OpenSSL 1.1.1 or higher used as cryptolib.
  • Crypto:
  • Typing in crypto and public_key applications are reworked and corrected.
  • New chapter on Algorithm details in the User's guide
  • ERTS, Kernel:
  • The socket options recvtos, recvttl, recvtclass and pktoptions have been implemented in the socket modules. Se documentation in gen_tcp, gen_udp and inet modules for more info!

New in Erlang OTP 20.3 (9.3) (Mar 14, 2018)

  • Application(s): ssl:
  • Added new API functions to facilitate cipher suite handling
  • Application(s): erts, observer:
  • More crash dump info such as: process binary virtual heap stats, full info for process causing out-of-mem during GC, more port related info, and dirty scheduler info.
  • Application(s): inets:
  • Add support for unix domain sockets in the http client.

New in Erlang OTP 20.2 (9.2) (Jan 10, 2018)

  • crypto, ssl:
  • The crypto API is extended to use private/public keys stored in an Engine for sign/verify or encrypt/decrypt operations.
  • The ssl application provides an API to use this new engine concept in TLS.
  • ssh:
  • SSH can now fetch the host key from the private keys stored in an Engine. See the crypto application for details about Engines.
  • ssl:
  • A new command line option -ssl_dist_optfile has been added to facilitate specifying the many options needed when using SSL as the distribution protocol.
  • stdlib:
  • Improve performance of the new string functionality when handling ASCII characters.

New in Erlang OTP 20.1 (Jan 10, 2018)

  • crypto, public_key: Extend crypto and public_key functions sign and verify with:
  • support for RSASSA-PS padding for signatures and for saltlength setting
  • X9.31 RSA padding.
  • sha, sha224, sha256, sha384, and sha512 for dss signatures as mentioned in NIST SP 800-57 Part 1.
  • ripemd160 to be used for rsa signatures.
  • A new tuple in crypto:supports/0 reports supported MAC algorithms.
  • diameter:
  • Add service option decode_format to allow incoming messages to be decoded into maps
  • instead of records.
  • Decode performance has been improved.
  • Add service/transport option avp_dictionaries to give better support for dictionaries only defining AVPs.
  • erts: Upgraded the ERTS internal PCRE library from version 8.40 to version 8.41.
  • erts, kernel, tools: Profiling with lock counting can now be fully toggled at runtime in the lock counting emulator (-emu_type lcnt). Everything is enabled by default to match the old behavior, but specific categories can be toggled at will with minimal
  • runtime overhead when disabled. Refer to the documentation on lcnt:rt_mask/1 for details.
  • lcnt:collect and lcnt:clear will no longer block all
  • other threads in the runtime system. This makes it possible to run the lock counting
  • under heavier load.
  • erts: The zlib module has been refactored and all its operations will now yield appropriately, allowing them to be used freely in concurrent applications.
  • erts, tools: Add erlang:iolist_to_iovec/1, which converts an iolist() to an erlang:iovec(), which is suitable for use with enif_inspect_iovec().
  • erts: Add new nif API functions for managing an I/O Queue.
  • The added functions are: enif_ioq_create(), enif_ioq_destroy(), enif_ioq_enq_binary(),
  • enif_ioq_enqv(), enif_ioq_deq(), enif_ioq_peek(), enif_inspect_iovec(), enif_free_iovec()
  • observer/crashdump_viewer:
  • Reading of crash dumps with many binaries is optimized.
  • A progress bar is shown when the detail view for a process is opened.
  • The cdv script now sets ERL_CRASH_DUMP_SECONDS=0 to
  • avoid generating a new crash dump from the node running the Crashdump Viewer.
  • observer:
  • Add system statistics and limits to frontpage in observer.
  • public_key, ssl**:
  • Improved error propagation and reports
  • ssh: A new option modify_algorithms is implemented. It enables specifying changes on the default algorithms list. See the reference manual and the SSH User's Guide chapter "Configuring algorithms in SSH".
  • tools/xref: The predefined Xref analysis locals_not_used now understands tools/fprof: When sampling multiple processes and analyzing with totals set to true, the output now sums together all caller and callee entries which concerns the same function. Previous behaviour was to report each contributing entry separately.

New in Erlang OTP 20.0 (Jan 10, 2018)

  • Potential Incompatibilities:
  • ERTS:
  • The non SMP Erlang VM is deprecated and not built by default
  • Remove deprecated erlang:hash/2
  • erlang:statistics/1 with scheduler_wall_time now also includes info about dirty CPU schedulers.
  • The new purge strategy introduced in OTP 19.1 is mandatory and slightly incompatible for processes holding funs
  • see erlang:check_process_code/3.
  • The NIF library reload is not supported anymore.
  • Atoms can now contain arbitrary unicode characters which means that the DFLAG_UTF8_ATOMS capability in the distribution protocol must be supported if an OTP 20 node should accept the connection with another node or library. Third party libraries which uses the distribution protocol need to be updated with this.
  • Asn1: Deprecated module and functions removed (asn1rt, asn1ct:encode/3 and decode/3)
  • Ssh: client only option in a call to start a daemon will now fail
  • HIGHLIGHTS:
  • Erts:
  • Dirty schedulers enabled and supported on VM with SMP support.
  • support for “dirty” BIFs and “dirty” GC.
  • erlang:garbage_collect/2 for control of minor or major GC
  • Erlang literals are no longer copied when sending messages.
  • Improved performance for large ETS tables, >256 entries (except ordered_set)
  • erlang:system_info/1 atom_count and atom_limit
  • Reduced memory pressure by converting sub-binaries to heap-binaries during GC
  • enif_select, map an external event to message
  • Improvements of timers internally in the VM resulting in reduced memory consumption and more efficient administration for timers
  • Compiler:
  • Code generation for complicated guards is improved.
  • Warnings for repeated identical map keys. #{'a'=>1, 'b'=>2, 'a'=>3} will warn for the repeated key a.
  • By default there is now a warning when export_all is used. Can be disabled
  • Pattern matching for maps is optimized
  • New option deterministic to omit path to source + options info the BEAM file.
  • Atoms may now contain arbitrary unicode characters.
  • compile:file/2 has an option to include extra chunks in the BEAM file.
  • Misc other applications:
  • Significantly updated string module with unicode support and many new functions
  • crypto now supports OpenSSL 1.1
  • Unnamed ets tables optimized
  • gen_fsm is deprecated and replaced by gen_statem
  • A new event manager to handle a subset of OS signals in Erlang
  • Optimized sets add_element, del_element and union
  • Added rand:jump/0-1
  • When a gen_server crashes, the stacktrace for the client will be printed to facilitate debugging.
  • take/2 has been added to dict, orddict, and gb_trees.
  • take_any/2 has been added to gb_trees
  • erl_tar support for long path names and new file formats
  • asn1: the new maps option changes the representation of SEQUENCE to be maps instead of records
  • A TLS client will by default call public_key:pkix_verify_hostname/2 to verify the hostname
  • ssl: DTLS documented in the API, experimental
  • ssh: improving security, removing and adding algorithms
  • New math:fmod/2

New in Erlang OTP 17.0 (Apr 10, 2014)

  • Erlang/OTP has been ported to the realtime operating system OSE.
  • Maps, a new dictionary data type (experimental)
  • A more natural mapping from ASN.1 OCTET STRING and BIT STRING to Erlang types, and other ASN.1 improvements and optimizations
  • The {active, N} socket option for TCP, UDP, and SCTP
  • A new (optional) scheduler utilization balancing mechanism
  • Migration of memory carriers has been enabled by default on all ERTS internal memory allocators
  • Increased garbage collection tenure rate
  • Experimental "dirty schedulers" functionality
  • Funs can now be given names
  • Miscellaneous unicode support enhancements
  • A new version scheme for OTP its applications has been introduced

New in Erlang OTP R15B02 (Sep 5, 2012)

  • Dialyzer: The type analysis tool Dialyzer is optimized to be generally faster. - It can now also run in parallel (default) on SMP systems and by this perform the analysis significantly faster (Thanks to Stavros Aronis and Kostis Sagonas)
  • The SSL application now has experimental support for the TLS 1.1 and 1.2 standards as well (Thanks to Andreas Schultz).
  • CommonTest: It is now possible to sort the generated html tables. A Netconf client (ct_netconf) which support basic netconf over ssh is added
  • Diameter: Statistics counters related to Diameter messages can now be retrieved by calling the diameter:service_info/2 function.
  • Various smaller optimizations in the Erlang VM
  • This release also contains 66 contributions from users outside the Ericsson team

New in Erlang OTP R15B01 (Sep 5, 2012)

  • Added erlang:statistics(scheduler_wall_time) to ensure correct determination of scheduler utilization. Measuring scheduler utilization is strongly preferred over CPU utilization, since CPU utilization gives very poor indications of actual scheduler/vm usage.
  • Changed ssh implementation to use the public_key application for all public key handling. This is also a first step for enabling a callback API for supplying public keys and handling keys protected with password phrases. Additionally the test suites where improved so that they do not copy the users keys to test server directories as this is a security liability. Also ipv6 and file access issues found in the process has been fixed.
  • When an escript ends now all printout to standard output and standard error gets out on the terminal. This bug has been corrected by changing the behaviour of erlang:halt/0,1, which should fix the same problem for other escript-like applications, i.e. that data stored in the output port driver buffers got lost when printing on a TTY and exiting through erlang:halt/0,1. The BIF:s erlang:halt/0,1 has gotten improved semantics and there is a new BIF erlang:halt/2 to accomplish something like the old semantics. See the documentation.
  • The DTrace source patch from Scott Lystig Fritchie is integrated in the source tree. Using an emulator with dtrace probe is still not supported for production use, but may be a valuable debugging tool. Configure with --with-dynamic-trace=dtrace (or --with-dynamic-trace=systemtap) to create a build with dtrace probes enabled. See runtime_tools for documentation and examples
  • Added Torbjörn Törnkvists LDAP client as a new application called eldap.
  • Added options for the ssh client to support user keys files that are password protected.

New in Erlang OTP R15B (Sep 5, 2012)

  • Line number and filename information are now included in exception backtraces. This information will be pretty-printed in the shell and used in crash reports etc. In practice it will be much easier to find where something failed.
  • The driver interface has been changed to enable 64-bit aware drivers. Most importantly the return types for ErlDrvEntry callbacks 'call' and 'control' has been changed which require drivers to be changed.
  • New in this release is the support for 64 bit Windows. The self extracting installer can be found here.
  • CommonTest hooks are now in a final supported version.
  • There is a new GUI tool in the observer application which integrates pman, etop, appmon and tv into one tool. The tool does also contain functions for activating tracing in an easy way.
  • The Erlang distribution can now be run over the new SSL implementation.

New in Erlang OTP R14B03 (Sep 5, 2012)

  • Initial release of the diameter application

New in Erlang OTP R14B02 (Sep 5, 2012)

  • The "halfword" emulator is now official. A 64-bit emulator that uses less memory than the full 64 bit emulator.
  • EDoc handles Erlang specifications and types.
  • All test suites now run with CommonTest