Swift is the only language that scales from embedded devices and
kernels to apps and cloud infrastructure. It's simple, and
expressive, with incredible performance and safety. And it has
unmatched interoperability with C and C++.
It's the combination of approachability, speed, safety, and all of
Swift's strengths that make it so unique.
WWW: https://www.swift.org/
PR: 296000
Differential Revision: https://reviews.freebsd.org/D57541
GCC-15 Ada Port:
* Add GNAT-15 to the Ports Tree
* Add xz:threads option to ${TAR} to make use of multi-threaded
compression
* Add GNU OpenMP libraries. This is required for GNATColl Bindings
* Add GNAT and GNAT_SO_VERSION to ${PLIST_SUB} to remove hard-coded
version dependent information. The aim here is to reduce work
updating the Port, or using the pkg-plist to bootstrap the next major
release
* Complete ${LICENSE} block
* Expand pkg-message and make UCL compliant
* Modernise and update ${COMMENT}, ${WWW} and pkg-descr
https://gcc.gnu.org/gcc-15/changes.html#ada
PR: 292708
Co-authored-by: Alastair Hogge <agh@riseup.net>
Co-authored-by: Marcin Cieślak <saper@saper.info>
Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.
WWW: https://www.lua.org/
PR: 295279
Reviewed by: vvd
Approved by: portmgr (implicit)
Differential Revision: https://reviews.freebsd.org/D57001
Babashka is a native, fast-starting Clojure interpreter for scripting.
It uses GraalVM native-image to produce a self-contained binary that
starts instantly, making Clojure practical for shell scripting and
command-line tools.
This port installs a statically-linked Linux binary that runs via
FreeBSD's Linux binary compatibility layer (Linuxulator).
WWW: https://babashka.org/
GCC, the GNU Compiler Collection, supports a number of languages.
This port installs the C, C++, and Fortran front ends as gcc16,
g++16, and gfortran16, respectively.
This is the first release from the GCC 16 series.
It largely is a copy of lang/gcc16-devel, with release-specific
modifications from lang/gcc15.
Common issues that could happen when porting code to GCC 16:
https://gcc.gnu.org/gcc-16/porting_to.html
Changes: https://gcc.gnu.org/gcc-16/changes.html
GCC, the GNU Compiler Collection, supports a number of languages.
This port installs the C, C++, and Fortran front ends as gcc17, g++17,
and gfortran17, respectively.
This is the first snapshot from trunk with the GCC 17 designation.
It largely is a copy of lang/gcc16-devel.
Asmc is a slow-burning attempt of making a functional programming
language out of assembly. It supports AVX-512 instructions (Masm v14)
but the Version macro is currently set to v10. The assembler is
written in assembly and is open source under the GNU General Public
License. It runs on Windows and Linux.
NOTE: this assembler is written in assembly and has its own structure
definitions for Linux that it uses when it builds itself. While these
are wrong on FreeBSD, the set of library calls it does is small and
only readdir() and sigaction() seem to possibly diverge. However,
this does not seem to cause any observable problems when using asmc to
build the LZMA SDK on amd64, though there is a crash on i386 I need to
investigate further.
WWW: https://github.com/nidud/asmc
From https://go.dev/doc/go1.26:
The latest Go release, version 1.26, arrives in February 2026, six
months after Go 1.25. Most of its changes are in the implementation
of the toolchain, runtime, and libraries. As always, the release
maintains the Go 1 promise of compatibility. We expect almost all Go
programs to continue to compile and run as before.
There are exciting updates in this new Go minor:
- New Green Tea-based garbage collector that cuts GC overhead by an
observed 10-40%.
- cgo runtime overhead reduced by an observed 30%.
- `go fix` has been rewritten as is now Go's official modernizer. In
particular, it includes all of `go vet`'s heuristics, making it
possible to fix the things that the latter identifies.
- Heap base address is now randomized.
- pprof can now (experimentally) identify leaked goroutines.
- New crypto/hpke package includes support for quantum-vulnerable and
post-quantum hybrid KEMs.
Go's support lifecycle is current minor and current-1. New minors are
released every 6 months, so any minor is supported for one year. There
are no LTS versions.
With des's phenomenal work on go.mk, it was finally possible to
resolve the remaining hard deps on these old versions.
This port is required by games/lwjgl3. Since Kotlin 2.3.0, Ant support has been
removed, but lwjgl3 has complex long ongoing migration story from Ant to
Gradle.
Hopefully after migration the port may be removed.
PR: 292099
Reported by: vvd@
Zig is making lots of breaking changes from 0.14
to 0.15 consumers aren't necessarily keeping up.
Create the lang/zig014 as a tempoirary solution
for ports depending on zig 0.14
PR: 289011
Approved by: Pero Oršolić <bsd@orsolic.org> (maintainer)