Open source projects

A Rust framework for implementing AWS AppSync Direct Lambda resolvers with type safety and compile-time validation. Automatically generates Rust types from your GraphQL schema and routes operations to the correct handlers.

• Type generation from GraphQL schema via procedural macro
• Automatic operation routing (Query, Mutation, Subscription) to dedicated implementations
• Typed error handling conforming to the AppSync protocol
• Multi-mode authentication support (API key, Cognito, IAM, OIDC)
• Compatible with the official Rust Lambda runtime

Out-of-the-box OpenTelemetry instrumentation for AWS Lambda functions using the AWS SDK for Rust. Automatically emits traces and structured logs for every AWS API call. When paired with the X-Ray exporter I contributed to opentelemetry-rust-contrib, traces flow natively into the AWS observability ecosystem.

• Automatic OpenTelemetry traces for all AWS SDK calls
• Latency and error rate metrics per service and operation
• Optional AWS X-Ray exporter (via my opentelemetry-rust-contrib contribution)
• Zero-config: a single macro instruments everything
• Compatible with the offcial Rust Lambda runtime

An ergonomic, typed facade over the AWS SDK DynamoDB client for Rust. Eliminates manual key maps, expression strings, pagination loops, and batch chunking — while enforcing correct usage at compile time through typestate builders and a schema encoded in the type system.

• Zero-boilerplate item wiring via declarative macros (table, attribute, and index definitions as zero-sized types)
• Composable, typed condition and update expression builders — no `#name` / `:value` juggling
• Typestate operation builders: forgetting the sort key, setting a condition twice, and similar misuses are compile-time errors
• Auto-paginating query & scan (collect or stream)
• First-class single-table (mono-table) design support

An 18k-line upstream contribution across 46 files to the OpenTelemetry Rust Contrib project, adding AWS X-Ray support to the OpenTelemetry Rust ecosystem. PR #549 was merged on 11 June 2026, after review by the project maintainers. This work is what awssdk-instrumentation's X-Ray exporter is built on.

• X-Ray span and trace exporter, mapping OpenTelemetry semantics to the X-Ray data model
• X-Ray daemon client for UDP delivery to the local X-Ray agent
• Stdout client for tracing from environments without a daemon (CloudWatch Logs ingestion, local debugging)

A friendly Lambda benchmark built around streaming S3 archive creation. Two blog posts are dedicated to it if you want to learn more.

• Parallel benchmark ranking contenders by real Lambda invocation cost
• Control Lambda validating the produced ZIP byte-for-byte
• Bucket pre-filled with 3,000 random objects (~15 GB)
• Open contender contract accepting submissions in any language
• CI/CD deployment from a simple repo fork

A multiplayer economy game showcasing the full RustySL stack end-to-end on AWS. Built on AppSync with Rust Lambda direct resolvers powered by lambda-appsync, a single-table DynamoDB backend accessed through dynamodb-facade, and instrumented with awssdk-instrumentation — all fronted by a SvelteKit static site on CloudFront and deployed through CodePipeline V2.

• Rust Lambda direct resolvers on AppSync with batching and subscriptions
• Dedicated sub-stack comparing six Lambda instrumentation strategies side by side (4 Python, 2 Rust)
• Single-table DynamoDB design with Cognito auth and X-Ray tracing
• CI/CD deployment from a simple repo fork

An interactive clicking game that benchmarks four AppSync resolver implementations in real time: Rust Lambda, Python Lambda, JavaScript resolver, and VTL resolver. The Rust resolver is built with lambda-appsync and dynamodb-facade, and the project doubles as a reference deployment for both crates.

• Four-way resolver benchmark (Rust / Python / JS / VTL) driven by player clicks
• Vue.js frontend on CloudFront, CodePipeline deployment, Cognito auth
• Load-test CLI (simulate_players) for synthetic benchmarking
• CI/CD deployment from a simple repo fork

The first demo: a head-to-head comparison of Rust and Python AWS Lambda functions exposed through parallel API Gateways, benchmarked on various workloads (Ackermann, prime numbers, DynamoDB). The published results show Rust at roughly 50× faster, 33× cheaper, and 4× less memory-hungry than Python on the same tasks.

• Two parallel API Gateways, one Rust runtime and one Python, sharing a DynamoDB backend
• CPU workloads designed to stress cold-start and warm-execution paths
• CloudWatch Log Insights queries for reproducible measurement, results published as a public spreadsheet
• CI/CD deployment from a simple repo fork