Skip to main content
@effect/platform provides unified, platform-independent abstractions for Node.js, Bun, and browsers. It enables you to write code once and run it across different environments.

​
Installation

npm install @effect/platform

​
Platform-Specific Packages

Install the appropriate runtime package for your environment:

Node.js

npm install @effect/platform-node

Bun

npm install @effect/platform-bun

Browser

npm install @effect/platform-browser

​
Core Services

​
HttpClient

Make HTTP requests with full type safety and composability. 
import { HttpClient } from "@effect/platform"
import { Effect } from "effect"

const program = Effect.gen(function* () {
  const client = yield* HttpClient.HttpClient
  const response = yield* client.get("https://api.example.com/users")
  const users = yield* response.json
  return users
})

​
FileSystem

Platform-independent file system operations. 
import { FileSystem } from "@effect/platform"
import { Effect } from "effect"

const program = Effect.gen(function* () {
  const fs = yield* FileSystem.FileSystem
  const content = yield* fs.readFileString("config.json")
  yield* fs.writeFileString("output.txt", content)
})

​
Command

Execute system commands safely. 
import { Command } from "@effect/platform"
import { Effect } from "effect"

const program = Effect.gen(function* () {
  const command = Command.make("git", "status")
  const result = yield* Command.exitCode(command)
  yield* Effect.log(`Exit code: ${result}`)
})

​
HTTP API

Define declarative, type-safe HTTP APIs with automatic client generation and Swagger documentation. 
import {
  HttpApi,
  HttpApiBuilder,
  HttpApiEndpoint,
  HttpApiGroup
} from "@effect/platform"
import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
import { Effect, Layer, Schema } from "effect"
import { createServer } from "node:http"

const User = Schema.Struct({
  id: Schema.Number,
  name: Schema.String
})

const api = HttpApi.make("MyApi").add(
  HttpApiGroup.make("Users").add(
    HttpApiEndpoint.get("getUsers", "/users").addSuccess(Schema.Array(User))
  )
)

const usersLive = HttpApiBuilder.group(api, "Users", (handlers) =>
  handlers.handle("getUsers", () =>
    Effect.succeed([{ id: 1, name: "Alice" }])
  )
)

const apiLive = HttpApiBuilder.api(api).pipe(Layer.provide(usersLive))

const server = HttpApiBuilder.serve().pipe(
  Layer.provide(apiLive),
  Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 }))
)

Layer.launch(server).pipe(NodeRuntime.runMain)

​
Key Features

  • Platform Independence: Write once, run on Node.js, Bun, or browsers
  • Type Safety: Full TypeScript support with schema validation
  • Composability: Combine services using Effect’s powerful composition
  • Error Handling: Built-in error types and recovery mechanisms
  • Testability: Easy to mock and test with dependency injection

@effect/platform-node

Node.js runtime implementation

@effect/platform-bun

Bun runtime implementation

@effect/platform-browser

Browser runtime implementation

API Reference

Complete API documentation

Build docs developers (and LLMs) love

Get started for freeTalk to us