diff --git a/internal/format/format.go b/internal/format/format.go
new file mode 100644
index 0000000..3bcabc3
--- /dev/null
+++ b/internal/format/format.go
@@ -0,0 +1,31 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package format contains types for defining language-specific formatting of
+// values.
+//
+// This package is internal now, but will eventually be exposed after the API
+// settles.
+package format
+
+import (
+	"fmt"
+
+	"golang.org/x/text/language"
+)
+
+// State represents the printer state passed to custom formatters. It provides
+// access to the fmt.State interface and the sentence and language-related
+// context.
+type State interface {
+	fmt.State
+
+	// Language reports the requested language in which to render a message.
+	Language() language.Tag
+
+	// TODO: more info:
+	// - sentence context
+	// - user preferences, like measurement systems
+	// - options
+}
diff --git a/message/message.go b/message/message.go
new file mode 100644
index 0000000..25f47db
--- /dev/null
+++ b/message/message.go
@@ -0,0 +1,91 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package message implements formatted I/O for localized strings with functions
+// analogous to the fmt's print functions.
+//
+// Under construction. See https://golang.org/design/text/12750-localization
+// and its corresponding proposal issue https://golang.org/issues/12750.
+package message
+
+import (
+	"fmt"
+	"io"
+
+	"golang.org/x/text/internal/format"
+	"golang.org/x/text/language"
+)
+
+// A Printer implements language-specific formatted I/O analogous to the fmt
+// package. Only one goroutine may use a Printer at the same time.
+type Printer struct {
+	tag language.Tag
+
+	// NOTE: limiting one goroutine per Printer allows for many optimizations
+	// and simplifications. We can consider removing this restriction down the
+	// road if it the benefits do not seem to outweigh the disadvantages.
+}
+
+// NewPrinter returns a Printer that formats messages tailored to language t.
+func NewPrinter(t language.Tag) *Printer {
+	return &Printer{tag: t}
+}
+
+// Sprint is like fmt.Sprint, but using language-specific formatting.
+func (p *Printer) Sprint(a ...interface{}) string {
+	return fmt.Sprint(p.bindArgs(a)...)
+}
+
+// Fprint is like fmt.Fprint, but using language-specific formatting.
+func (p *Printer) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, p.bindArgs(a)...)
+}
+
+// Print is like fmt.Print, but using language-specific formatting.
+func (p *Printer) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(p.bindArgs(a)...)
+}
+
+// bindArgs wraps arguments with implementation of fmt.Formatter, if needed.
+func (p *Printer) bindArgs(a []interface{}) []interface{} {
+	out := make([]interface{}, len(a))
+	for i, x := range a {
+		switch v := x.(type) {
+		case fmt.Formatter:
+			// Wrap the value with a Formatter that augments the State with
+			// language-specific attributes.
+			out[i] = &value{v, p}
+
+			// NOTE: as we use fmt.Formatter, we can't distinguish between
+			// regular and localized formatters, so we always need to wrap it.
+
+			// TODO: handle
+			// - numbers
+			// - lists
+			// - time?
+		default:
+			out[i] = x
+		}
+	}
+	return out
+}
+
+// state implements "golang.org/x/text/internal/format".State.
+type state struct {
+	fmt.State
+	p *Printer
+}
+
+func (s *state) Language() language.Tag { return s.p.tag }
+
+var _ format.State = &state{}
+
+type value struct {
+	x fmt.Formatter
+	p *Printer
+}
+
+func (v *value) Format(s fmt.State, verb rune) {
+	v.x.Format(&state{s, v.p}, verb)
+}
diff --git a/message/message_test.go b/message/message_test.go
new file mode 100644
index 0000000..2c47701
--- /dev/null
+++ b/message/message_test.go
@@ -0,0 +1,49 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package message
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"testing"
+
+	"golang.org/x/text/internal/format"
+	"golang.org/x/text/language"
+)
+
+type formatFunc func(s fmt.State, v rune)
+
+func (f formatFunc) Format(s fmt.State, v rune) { f(s, v) }
+
+func TestBinding(t *testing.T) {
+	testCases := []struct {
+		tag   string
+		value interface{}
+		want  string
+	}{
+		{"en", 1, "1"},
+		{"en", "2", "2"},
+		{ // Language is passed.
+			"en",
+			formatFunc(func(fs fmt.State, v rune) {
+				s := fs.(format.State)
+				io.WriteString(s, s.Language().String())
+			}),
+			"en",
+		},
+	}
+	for i, tc := range testCases {
+		p := NewPrinter(language.MustParse(tc.tag))
+		if got := p.Sprint(tc.value); got != tc.want {
+			t.Errorf("%d:%s:Sprint(%v) = %q; want %q", i, tc.tag, tc.value, got, tc.want)
+		}
+		var buf bytes.Buffer
+		p.Fprint(&buf, tc.value)
+		if got := buf.String(); got != tc.want {
+			t.Errorf("%d:%s:Fprint(%v) = %q; want %q", i, tc.tag, tc.value, got, tc.want)
+		}
+	}
+}