awslabs/swift-aws-lambda-runtime

This system is the official Swift runtime library and tooling for building and deploying AWS Lambda functions. It provides the core execution environment, including support for async handlers, structured JSON logging, response streaming, and tenant isolation. The project also includes a suite of Swift Package Manager plugins that automate project scaffolding, cross-compilation, and deployment to AWS as either ZIP archives or OCI container images.

16 changes.

The project underwent a major overhaul by removing the legacy SwiftAwsLambda implementation and introducing the new LambdaSwift 2.0 runtime with structured logging and tenant support. This period focused on modernizing the codebase through comprehensive testing, CI script improvements, and migrating examples to the new async/await-based API. A significant effort was also directed toward expanding the example suite to cover diverse use cases, including S3 integration, background tasks, and CDK deployments.

19 changes.

This period focused on the v3 release of the Swift AWS Lambda Runtime, introducing async APIs, Foundation JSON support, and new Swift Package Manager deployment plugins. The work heavily emphasized comprehensive documentation and a wide array of examples covering various AWS integrations, including API Gateway, S3, PostgreSQL, and streaming responses.

13 changes.

This period focused on the major release of AWS Lambda Runtime 2.0, featuring a complete rewrite of the HTTP client for Swift 6 concurrency, support for Managed Instances, and new handler abstractions. It also introduced a comprehensive v2 plugin system for Swift Package Manager, enabling streamlined project initialization, building, and deployment of Lambda functions as both ZIP archives and OCI container images.

A new example demonstrating how to invoke an AWS Lambda function via an Amazon API Gateway V1 (REST API) endpoint has been added. This example uses the \APIGatewayRequest\ and \APIGatewayResponse\ types from the Swift AWS Lambda Events library to echo HTTP headers back to the client, and includes a SAM template for deploying the infrastructure on Amazon Linux 2023.

Examples/APIGatewayV1 · high confidence

New example source files have been added for both the AWS SDK for Swift and the Soto library, demonstrating how to list S3 buckets within a Lambda function triggered by an API Gateway V2 event. These examples provide reference implementations for users integrating S3 operations with serverless Swift runtimes.

_Examples/S3\_AWSSDK/Sources, Examples/S3\Soto/Sources · high confidence

A new CDK stack example has been added to the infrastructure directory, demonstrating how to deploy a Swift Lambda function via an HTTP API Gateway. The configuration specifies the Amazon Linux 2023 (AL2023) runtime on ARM64 architecture, uses a 128MB memory allocation with a 30-second timeout, and outputs the resulting API URL for easy access.

Examples/CDK/infra · high confidence

This change introduces a new \FoundationJSONSupport\ feature that enables JSON encoding and decoding for Lambda functions using Swift's Foundation types. It adds vendored utilities to convert between \ByteBuffer\ and \Foundation.Data\, and provides \LambdaJSONEventDecoder\ and \LambdaJSONOutputEncoder\ to handle JSON serialization. For users, this means they can now initialize \LambdaRuntime\ and \LambdaManagedRuntime\ with closures that accept and return \Decodable\/\Encodable\ types (like custom structs) directly, with JSON handling performed automatically via \JSONDecoder\ and \JSONEncoder\. It also adds a convenience \deadlineDate\ property to \LambdaContext\ for easier date handling.

Sources/AWSLambdaRuntime/FoundationSupport · high confidence

Introduces a new example application in Examples/HelloJSON that demonstrates how to build, deploy, and invoke an AWS Lambda function using Swift. The example includes source code for handling JSON input and output, a README with build and deployment instructions using the lambda-build and lambda-deploy plugins, and a .gitignore file to exclude generated artifacts.

Examples/HelloJSON · high confidence

Added a new example demonstrating how to build and deploy a Hummingbird web application on AWS Lambda using API Gateway V2. The example includes source code for a simple HTTP endpoint, a SAM template for infrastructure deployment, and documentation covering build, deploy, and invoke steps.

Examples/HummingbirdLambda · high confidence

The Examples/JSONLogging directory now provides a complete Swift Lambda example demonstrating structured JSON logging. It shows how to configure the runtime to output logs as JSON objects (including request and trace IDs) by setting the \AWS\_LAMBDA\_LOG\_FORMAT\ environment variable or the SAM \LoggingConfig.LogFormat\ property. The example code illustrates using \context.logger\ and the task-local \Logger.current\ to automatically include invocation metadata in logs from helper functions without threading parameters, and includes a SAM template for deployment on Amazon Linux 2023.

Examples/JSONLogging · high confidence

Introduces a new mock HTTP server (Sources/MockServer/MockHTTPServer.swift) to facilitate local testing of Lambda functions. This tool listens on a configurable host and port, simulating the Lambda Runtime API by handling invocation requests and returning hardcoded responses based on a specified mode (string or JSON). It supports a configurable maximum number of invocations before shutting down, allowing developers to validate their function's interaction with the runtime environment without deploying to AWS.

Sources/MockServer · high confidence

A new example project has been added to demonstrate a Lambda function that accepts requests from both Application Load Balancer (ALB) and API Gateway V2. The Swift handler decodes incoming raw \ByteBuffer\ events to determine the source type and returns an appropriate response, while the included SAM template provisions the necessary AWS resources, including an HTTP API, an Application Load Balancer, and associated VPC infrastructure.

Examples/MultiSourceAPI · high confidence

This change introduces a new example demonstrating how to bundle static resources (such as text files) into a Swift AWS Lambda function using Swift Package Manager. The example includes a handler that reads a bundled \hello.txt\ file at runtime, along with documentation on how to build, package, and deploy the function using the \lambda-build\ and \lambda-deploy\ plugins, and how to invoke it locally or via the AWS CLI.

Examples/ResourcesPackaging · high confidence

This location introduces a new example demonstrating how to run a Swift AWS Lambda function backed by a PostgreSQL database using the ServiceLifecycle framework. The example includes a main Lambda handler that manages the lifecycle of a Postgres client and a prelude service for database initialization, along with supporting utilities such as a custom timeout wrapper to handle database connectivity issues, a prelude service implementation, and embedded AWS RDS root certificates for secure TLS connections in the us-east-1 and eu-central-1 regions.

Examples/ServiceLifecycle+Postgres/Sources · high confidence

Added a new example in the Examples/BackgroundTasks directory that demonstrates how to use the \LambdaWithBackgroundProcessingHandler\ protocol to execute asynchronous work after returning a response. The sample code shows how to write the immediate response via \outputWriter\, perform background processing (simulated with a 10-second sleep), and ensure the function waits for these tasks to complete before exiting, leveraging Lambda's response streaming capabilities.

Examples/BackgroundTasks · high confidence

The \Examples/Streaming+Codable/Sources\ location now includes a complete example demonstrating how to implement a streaming Lambda function that receives decoded JSON events and streams responses. This example showcases the \StreamingLambdaCodableAdapter\ and \LambdaRuntime\ convenience initializers, which automatically handle JSON decoding for both API Gateway and Lambda Function URL request formats, allowing users to easily adopt streaming responses in their own Lambda functions.

Examples/Streaming+Codable/Sources · high confidence

A new example project, S3EventNotifier, has been added to demonstrate how to write an AWS Lambda function that processes events triggered by Amazon S3. The example shows how to receive an S3Event, extract the bucket name and object key from the notification record, and handle URL-encoded keys. It includes a README with instructions for building, packaging, and deploying the Lambda function using the lambda-deploy plugin, along with AWS CLI commands to configure the S3 bucket to send events to the Lambda function. The example also includes a .gitignore file and a security and reliability notice for production deployments.

Examples/S3EventNotifier · high confidence

The tutorial now includes a Swift-based example demonstrating how to implement an AWS Lambda function using the AWSLambdaRuntime library. This new example features a handler that checks if input text is a palindrome and returns the result, providing users with a concrete reference for building serverless Swift applications on AWS.

Examples/Tutorial · high confidence

The lambda-build helper now includes generated Swift SDK clients for Amazon ECR, IAM, and Lambda (available in LambdaSwift 2.0+). This enables the plugin to programmatically manage container registries, create and configure IAM roles, and interact with the Lambda service during the build and deploy process.

Sources/AWSLambdaPluginHelper/lambda-build · high confidence

A new \AWSLambdaDeployer\ command plugin is added to the Swift Package Manager ecosystem, enabling users to deploy AWS Lambda functions directly from their packages. The plugin supports deploying executable products as either ZIP archives or OCI container images (via Docker or the \container\ CLI) and allows users to specify which products to deploy using the \--products\ argument.

Plugins/AWSLambdaDeployer · high confidence

This change adds the AWSLambdaPluginHelper executable, a shared tool invoked by SwiftPM plugins to scaffold (init), compile/package (build), and deploy Lambda functions. It features line-buffered stdout so plugin output streams in real-time rather than waiting for process exit, and includes a retry mechanism with exponential backoff and equal jitter to handle AWS eventual consistency (e.g., IAM propagation) during deployment. The helper also supports deploying Lambda functions as OCI container images and is modernized for Swift 6.4+ concurrency safety.

Sources/AWSLambdaPluginHelper · high confidence

The runtime now supports AWS Lambda Managed Instances by reading the AWS\_LAMBDA\_MAX\_CONCURRENCY environment variable and launching multiple Runtime Interface Clients when concurrency exceeds one, ensuring proper isolation via a runtime guard. This change also introduces a new set of handler protocols (StreamingLambdaHandler, LambdaHandler, LambdaWithBackgroundProcessingHandler) and corresponding closure-based implementations, along with codable adapters to simplify event decoding and response encoding for users.

Sources/AWSLambdaRuntime/Runtime · high confidence

Added two new example projects demonstrating AWS Lambda integration with API Gateway V2 (HTTP APIs). The \APIGatewayV2\ example shows a basic Lambda function handling HTTP requests and responses, while the \APIGatewayV2+LambdaAuthorizer\ example demonstrates a custom Lambda authorizer securing an API Gateway endpoint. Both examples use the \provided.al2023\ runtime, are deployed via AWS SAM, and include source code, SAM templates, and documentation.

Examples/APIGatewayV2, Examples/APIGatewayV2+LambdaAuthorizer · high confidence

Added a new example in the Examples/CDK directory that demonstrates deploying a Swift AWS Lambda function via Amazon API Gateway using the AWS Cloud Development Kit (CDK). The example includes the Lambda source code (main.swift), a TypeScript CDK infrastructure stack (infra/), and a README with instructions for building, deploying, invoking, and destroying the resources. It also includes a security and reliability notice recommending best practices such as enabling access logging, configuring concurrency limits, and setting up Dead Letter Queues.

Examples/CDK · high confidence

This change introduces a suite of new shell scripts to the \scripts/\ directory to support development workflows. It adds \check-doc.sh\ to validate documentation targets using the \swift-docc-plugin\, \check-format.sh\ and \check-format-linux.sh\ for Swift and YAML linting, and \check-license.sh\ to enforce Apache 2.0 headers. It also includes \generate-aws-clients.sh\ to scaffold and generate lightweight AWS service clients (Lambda, IAM, S3, STS, ECR) via the Soto code generator, and \integration-test.sh\ for end-to-end testing of the Lambda plugin system. Additionally, a new \lambda-performance/\ subdirectory provides \measure-cold-start.sh\ and \measure-warm-start.sh\ for measuring AWS Lambda startup times, alongside \local\_performance\_test.sh\ for local benchmarking and \linux\_performance\_setup.sh\ for configuring Linux profiling tools.

scripts · high confidence

The documentation has been migrated from the README to structured DocC articles, introducing a new step-by-step tutorial series. This series guides users through implementing a simple Lambda function, testing it locally using the embedded debug web server, and deploying it to AWS Lambda via the AWS Management Console and the new \lambda-build\ Swift Package Manager plugin.

Sources/AWSLambdaRuntime/Docs.docc/tutorials · high confidence

Added a new example in Examples/MultiTenant that demonstrates building a multi-tenant Lambda function using Swift and AWS Lambda's tenant isolation mode. The example includes Swift source code for handling API Gateway requests and local JSON payloads, an actor-based tenant data store for tracking per-tenant request counts, and a SAM template that configures the Lambda function with \TenancyConfig.TenantIsolationMode: PER\_TENANT\ and maps the API Gateway \tenant-id\ query parameter to the \X-Amz-Tenant-Id\ header required for tenant routing.

Examples/MultiTenant · high confidence

Added a new example demonstrating a Swift Lambda function using ServiceLifecycle to manage a PostgreSQL connection. The example includes a SAM template that deploys a network-isolated architecture with a private VPC, a PostgreSQL RDS instance (PostgreSQL 17.6), and an HTTP API Gateway, along with documentation, deployment scripts, and configuration files to guide users through setup and usage.

Examples/ServiceLifecycle+Postgres · high confidence

The \_MyFirstFunction example now includes helper scripts to streamline the developer experience. The create\_function.sh script automates the entire workflow: it scaffolds a Swift package, adds the AWS Lambda Runtime and Events dependencies (version 3.0.0), initializes the function code via the new lambda-init plugin, builds the Docker image, deploys to AWS Lambda, and invokes the function. A clean.sh script is also provided to remove the deployed Lambda function, IAM role, and local build artifacts, along with a .gitignore file to exclude generated files.

_Examples/\MyFirstFunction · high confidence

Added an example demonstrating how to package and deploy a Swift Lambda function as an OCI container image instead of a ZIP archive. This allows users to handle larger deployment packages (up to 10 GB), include extra binaries or system libraries, and integrate with existing container tooling. The example includes the necessary source code, build/deploy instructions using \--archive-format oci\, and a README explaining when to use container images versus ZIP archives.

Examples/OCIImage · high confidence

Added a new example in Examples/ManagedInstances that demonstrates how to deploy Swift Lambda functions to AWS Lambda Managed Instances using AWS SAM. The example includes three sample functions: HelloJSON for structured JSON input/output, Streaming for response streaming capabilities, and BackgroundTasks for long-running background processing after the response is sent. It provides a SAM template (template.yaml) configured for Amazon Linux 2023 (provided.al2023 runtime) with a capacity provider, along with Swift source code and a README with deployment and testing instructions.

Examples/ManagedInstances · high confidence

The \lambda-init\ helper now provides a new command to scaffold AWS Lambda projects. It automatically detects the project's entry point, backs up existing files, and writes a starter Lambda function template (supporting both URL and JSON event types). Additionally, it updates the \Package.swift\ manifest to require macOS 15 or later, ensuring compatibility with the Lambda runtime API availability requirements.

Sources/AWSLambdaPluginHelper/lambda-init · high confidence

Added two new example projects demonstrating how to implement response streaming in Swift AWS Lambda functions. The \Streaming+APIGateway\ example shows how to stream responses through an Amazon API Gateway REST API using a SAM template, while the \Streaming+FunctionUrl\ example demonstrates streaming via an authenticated Lambda Function URL, supporting both the \lambda-deploy\ plugin and AWS SAM deployment.

Examples/Streaming+APIGateway, Examples/Streaming+FunctionUrl · high confidence

The entire SwiftAwsLambda library implementation has been removed from the project. This includes the core Lambda runtime client, HTTP client, lifecycle management, and helper extensions for Codable and String payloads. As a result, applications can no longer use the SwiftAwsLambda package to run AWS Lambda functions in Swift.

Sources/SwiftAwsLambda · high confidence

A change to existing behaviour in Sources/AWSLambdaRuntime/Docs.docc/Resources/tutorials — 3 commits (1 fix), 34 files.

Sources/AWSLambdaRuntime/Docs.docc/Resources/tutorials · medium confidence · unverified

The HelloWorldNoTraits example has been migrated from the legacy synchronous SwiftAwsLambda API to the modern async AWSLambdaRuntime API. Users running this example will now see an asynchronous implementation using LambdaRuntime, reflecting the current runtime conventions for AWS Lambda functions in Swift.

Examples/HelloWorldNoTraits/Sources · high confidence

The \Sources/AWSLambdaRuntime\ module has been replaced with a new implementation targeting the \LambdaSwift 2.0\ availability level. This update introduces a \LambdaClock\ for precise deadline management and a \LambdaContext\ that now exposes \logGroupName\, \logStreamName\, and \tenantID\ to handlers. Logging behavior changes significantly: users can now configure \JSONLogHandler\ via the \AWS\_LAMBDA\_LOG\_FORMAT\ environment variable, which serializes logs to stderr with request and trace metadata. The runtime loop also supports streaming responses with custom HTTP headers via \StreamingLambdaStatusAndHeadersResponse\ and propagates single-concurrency mode settings.

Sources/AWSLambdaRuntime · high confidence

The \lambda-deploy\ helper has been rewritten for the v2 plugin system, introducing support for deploying Lambda functions as OCI container images (pushing to ECR and creating \PackageType=Image\ functions) alongside the existing ZIP deployment. The deployer now enforces build/deploy architecture consistency, failing with a clear error if the requested architecture does not match the built artifact, and verifies that the IAM execution role still exists before updating a function to prevent silent failures at invoke time. Additionally, it automatically detects the need for Function URLs by scanning source code for \FunctionURLRequest\ usage and creates them with IAM authentication when found.

Sources/AWSLambdaPluginHelper/lambda-deploy · high confidence

The AWS Lambda Builder and Initializer have been replaced with new v2 command plugins (AWSLambdaBuilder and AWSLambdaInitializer) that act as thin wrappers around the AWSLambdaPluginHelper executable. Users can now use \swift lambda-init\ to scaffold projects and \swift lambda-build\ to compile them, with the plugin handling argument extraction, cross-compilation tool selection (Swift static SDK, container, or Docker), and output directory resolution before delegating to the helper process.

Plugins/AWSLambdaBuilder · high confidence

The project has been renamed from SwiftAwsLambda to SwiftAWSLambdaRuntime, reflected in the updated README, CONTRIBUTING guidelines, and CONTRIBUTORS list. The documentation has been migrated to the Swift Package Index with new badges, a quick-start guide, and links to DocC articles. Compliance and governance files have been standardized, including a new license header template, a SECURITY.md for vulnerability reporting, and an adoption of the Amazon Open Source Code of Conduct. The .gitignore has been expanded to cover modern Swift toolchain artifacts, and the Makefile now includes targets for generating documentation and running tests across Swift 6.2, 6.3, and 6.4 toolchains.

(repo-wide) · high confidence

The HTTP client in \Sources/AWSLambdaRuntime/HTTPClient\ has been completely rewritten for LambdaSwift 2.0, introducing new \ControlPlaneRequest\ and \ControlPlaneResponse\ enums, a dedicated \ControlPlaneRequestEncoder\ for building HTTP requests, and a new \LambdaChannelHandler\ that manages the connection lifecycle and state transitions. This change replaces the previous implementation with a more robust, actor-based \LambdaRuntimeClient\ that improves stability and aligns with Swift 6 concurrency requirements.

Sources/AWSLambdaRuntime/HTTPClient · high confidence

The HelloWorld example has been moved to the Examples directory and updated to use the AWSLambdaRuntime library instead of the legacy SwiftAwsLambda package. The code now uses the modern LambdaRuntime API with async/await syntax, replacing the previous callback-based approach for handling Lambda events.

Examples/HelloWorld/Sources · high confidence

The documentation code samples in the quick-start guide have been updated to reflect the v3 release of the Swift AWS Lambda Runtime. The examples now target Swift 6.3, require macOS 15, and reference the runtime package version 3.0.0. The guide demonstrates the complete workflow for a new project, including initializing the package, defining request/response structures, implementing the Lambda handler using the new \LambdaRuntime\ API, and deploying via the new \lambda-build\ and \lambda-deploy\ Swift plugins.

Sources/AWSLambdaRuntime/Docs.docc/Resources/code · high confidence

The local testing server for AWS Lambda functions has been updated to resolve race conditions that previously caused NIOAsyncWriter fatal errors and test hangs. A new thread-safe \Pool\ data structure manages invocation and response continuations, ensuring that requests are correctly matched to their specific request IDs and that concurrent access is handled safely. This change stabilizes local development and testing workflows by preventing deadlocks and ensuring reliable request-response cycles.

Sources/AWSLambdaRuntime/HTTPServer · high confidence

Added Swift Testing example project; Added comprehensive test suite for SwiftAWSLambdaRuntime v2.0; Added tests for the Streaming Codable Lambda handler example; Added tests for the v2 Lambda plugin helper; Removal of legacy XCTest test suite; Removed LinuxMain.swift test runner.

The example projects in the Examples directory have been migrated to use the swift-aws-lambda-runtime library version 3.0.0, with most examples also depending on swift-aws-lambda-events version 1.0.0 (and specific examples like HummingbirdLambda, ServiceLifecycle+Postgres, S3\_AWSSDK, and S3\_Soto using updated versions of their respective third-party dependencies). Additionally, the CDK infrastructure example has been updated to use aws-cdk-lib version 2.268.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 67 → 66 (-0.8)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 89 → 91 (+1.3)
• Architecture 100 → 93 (-7.0)
• Maturity 61 → 62 (+0.4)
• Readiness 59 → 60 (+1.2)
• Security 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 64 (new)

• AWSLambdaBuilder.performCommand (cognitive 19) (Plugins/AWSLambdaBuilder/Plugin.swift)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Duplicated block (13 lines × 3) (Plugins/AWSLambdaBuilder/Plugin.swift)
• No Package.resolved committed (Examples/APIGatewayV1/Package.swift)
• No Package.resolved committed (Examples/APIGatewayV2+LambdaAuthorizer/Package.swift)
• No Package.resolved committed (Examples/APIGatewayV2/Package.swift)
• No Package.resolved committed (Examples/BackgroundTasks/Package.swift)
• No Package.resolved committed (Examples/CDK/Package.swift)
• No Package.resolved committed (Examples/HelloJSON/Package.swift)
• No Package.resolved committed (Examples/HelloWorld/Package.swift)
• No Package.resolved committed (Examples/HelloWorldNoTraits/Package.swift)
• No Package.resolved committed (Examples/HummingbirdLambda/Package.swift)
• No Package.resolved committed (Examples/JSONLogging/Package.swift)
• No Package.resolved committed (Examples/ManagedInstances/Package.swift)
• No Package.resolved committed (Examples/MultiSourceAPI/Package.swift)
• No Package.resolved committed (Examples/MultiTenant/Package.swift)
• No Package.resolved committed (Examples/OCIImage/Package.swift)
• No Package.resolved committed (Examples/ResourcesPackaging/Package.swift)
• No Package.resolved committed (Examples/S3EventNotifier/Package.swift)
• No Package.resolved committed (Examples/S3_AWSSDK/Package.swift)
• …and 8 more

• Coverage not measured — Swift suite
• Duplicate intent between LambdaManagedRuntime and LambdaRuntime. Both types accept a Handler and an EventLoop and have a run() method. It is unclear why two separate entry points exist for the same core functionality. This likely causes confusion for users about which type to instantiate.
• Inconsistent encoder/decoder handling in LambdaCodableAdapter. Some initializers require both encoder and decoder, while others only require a decoder (implying a default encoder or void output). This inconsistency extends to LambdaRuntime and LambdaManagedRuntime which also have mixed requirements for encoders/decoders across their initializers.
• Off-boarding risk: anonymized user #1
• Outdated (npm): aws-cdk-lib
• Projects may be oversized for their cohesion
• Redundant 'Exists' vs 'Active' semantics and V2 naming inconsistency. 'waitUntilFunctionExists' and 'waitUntilFunctionActiveV2' appear to perform the same polling operation (waiting for the function to be ready). The 'V2' suffix on 'Active' but not 'Exists' suggests an incomplete migration or inconsistent versioning strategy. Additionally, having two overloads (one taking a request object, one taking strings) is acceptable, but the semantic overlap between 'Exists' and 'Active' is confusing.
• Redundant types ClosureHandler and ClosureHandlerSendable. The naming suggests one is for non-sendable contexts and one for sendable, but the signatures are nearly identical. This creates unnecessary cognitive load and potential for misuse.

• 2 commits — 2 feature/other, 0 fixes

• .github/workflows — 1 commit
• Sources/AWSLambdaRuntime — 1 commit

• change: Migrate Examples to runtime 3.x (#700)
• change: add a public initializer to Lambda clock (#698)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

awslabs/swift-aws-lambda-runtime was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.