diff --git a/unicode/bidi/bidi.go b/unicode/bidi/bidi.go
index e8edc54..fd05760 100644
--- a/unicode/bidi/bidi.go
+++ b/unicode/bidi/bidi.go
@@ -12,15 +12,14 @@
 // and without notice.
 package bidi // import "golang.org/x/text/unicode/bidi"
 
-// TODO:
-// The following functionality would not be hard to implement, but hinges on
-// the definition of a Segmenter interface. For now this is up to the user.
-// - Iterate over paragraphs
-// - Segmenter to iterate over runs directly from a given text.
-// Also:
+// TODO
 // - Transformer for reordering?
 // - Transformer (validator, really) for Bidi Rule.
 
+import (
+	"bytes"
+)
+
 // This API tries to avoid dealing with embedding levels for now. Under the hood
 // these will be computed, but the question is to which extent the user should
 // know they exist. We should at some point allow the user to specify an
@@ -49,7 +48,9 @@
 	Neutral
 )
 
-type options struct{}
+type options struct {
+	defaultDirection Direction
+}
 
 // An Option is an option for Bidi processing.
 type Option func(*options)
@@ -66,12 +67,62 @@
 // DefaultDirection sets the default direction for a Paragraph. The direction is
 // overridden if the text contains directional characters.
 func DefaultDirection(d Direction) Option {
-	panic("unimplemented")
+	return func(opts *options) {
+		opts.defaultDirection = d
+	}
 }
 
 // A Paragraph holds a single Paragraph for Bidi processing.
 type Paragraph struct {
-	// buffers
+	p          []byte
+	o          Ordering
+	opts       []Option
+	types      []Class
+	pairTypes  []bracketType
+	pairValues []rune
+	runes      []rune
+	options    options
+}
+
+// Initialize the p.pairTypes, p.pairValues and p.types from the input previously
+// set by p.SetBytes() or p.SetString(). Also limit the input up to (and including) a paragraph
+// separator (bidi class B).
+//
+// The function p.Order() needs these values to be set, so this preparation could be postponed.
+// But since the SetBytes and SetStrings functions return the length of the input up to the paragraph
+// separator, the whole input needs to be processed anyway and should not be done twice.
+//
+// The function has the same return values as SetBytes() / SetString()
+func (p *Paragraph) prepareInput() (n int, err error) {
+	p.runes = bytes.Runes(p.p)
+	bytecount := 0
+	// clear slices from previous SetString or SetBytes
+	p.pairTypes = nil
+	p.pairValues = nil
+	p.types = nil
+
+	for _, r := range p.runes {
+		props, i := LookupRune(r)
+		bytecount += i
+		cls := props.Class()
+		if cls == B {
+			return bytecount, nil
+		}
+		p.types = append(p.types, cls)
+		if props.IsOpeningBracket() {
+			p.pairTypes = append(p.pairTypes, bpOpen)
+			p.pairValues = append(p.pairValues, r)
+		} else if props.IsBracket() {
+			// this must be a closing bracket,
+			// since IsOpeningBracket is not true
+			p.pairTypes = append(p.pairTypes, bpClose)
+			p.pairValues = append(p.pairValues, r)
+		} else {
+			p.pairTypes = append(p.pairTypes, bpNone)
+			p.pairValues = append(p.pairValues, 0)
+		}
+	}
+	return bytecount, nil
 }
 
 // SetBytes configures p for the given paragraph text. It replaces text
@@ -80,70 +131,150 @@
 // consumed from b including this separator. Error may be non-nil if options are
 // given.
 func (p *Paragraph) SetBytes(b []byte, opts ...Option) (n int, err error) {
-	panic("unimplemented")
+	p.p = b
+	p.opts = opts
+	return p.prepareInput()
 }
 
-// SetString configures p for the given paragraph text. It replaces text
-// previously set by SetBytes or SetString. If b contains a paragraph separator
+// SetString configures s for the given paragraph text. It replaces text
+// previously set by SetBytes or SetString. If s contains a paragraph separator
 // it will only process the first paragraph and report the number of bytes
-// consumed from b including this separator. Error may be non-nil if options are
+// consumed from s including this separator. Error may be non-nil if options are
 // given.
 func (p *Paragraph) SetString(s string, opts ...Option) (n int, err error) {
-	panic("unimplemented")
+	p.p = []byte(s)
+	p.opts = opts
+	return p.prepareInput()
 }
 
 // IsLeftToRight reports whether the principle direction of rendering for this
 // paragraphs is left-to-right. If this returns false, the principle direction
 // of rendering is right-to-left.
 func (p *Paragraph) IsLeftToRight() bool {
-	panic("unimplemented")
+	return p.Direction() == LeftToRight
 }
 
 // Direction returns the direction of the text of this paragraph.
 //
 // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral.
 func (p *Paragraph) Direction() Direction {
-	panic("unimplemented")
+	return p.o.Direction()
 }
 
+// TODO: what happens if the position is > len(input)? This should return an error.
+
 // RunAt reports the Run at the given position of the input text.
 //
 // This method can be used for computing line breaks on paragraphs.
 func (p *Paragraph) RunAt(pos int) Run {
-	panic("unimplemented")
+	c := 0
+	runNumber := 0
+	for i, r := range p.o.runes {
+		c += len(r)
+		if pos < c {
+			runNumber = i
+		}
+	}
+	return p.o.Run(runNumber)
+}
+
+func calculateOrdering(levels []level, runes []rune) Ordering {
+	var curDir Direction
+
+	prevDir := Neutral
+	prevI := 0
+
+	o := Ordering{}
+	// lvl = 0,2,4,...: left to right
+	// lvl = 1,3,5,...: right to left
+	for i, lvl := range levels {
+		if lvl%2 == 0 {
+			curDir = LeftToRight
+		} else {
+			curDir = RightToLeft
+		}
+		if curDir != prevDir {
+			if i > 0 {
+				o.runes = append(o.runes, runes[prevI:i])
+				o.directions = append(o.directions, prevDir)
+				o.startpos = append(o.startpos, prevI)
+			}
+			prevI = i
+			prevDir = curDir
+		}
+	}
+	o.runes = append(o.runes, runes[prevI:])
+	o.directions = append(o.directions, prevDir)
+	o.startpos = append(o.startpos, prevI)
+	return o
 }
 
 // Order computes the visual ordering of all the runs in a Paragraph.
 func (p *Paragraph) Order() (Ordering, error) {
-	panic("unimplemented")
+	if len(p.types) == 0 {
+		return Ordering{}, nil
+	}
+
+	for _, fn := range p.opts {
+		fn(&p.options)
+	}
+	lvl := level(-1)
+	if p.options.defaultDirection == RightToLeft {
+		lvl = 1
+	}
+	para, err := newParagraph(p.types, p.pairTypes, p.pairValues, lvl)
+	if err != nil {
+		return Ordering{}, err
+	}
+
+	levels := para.getLevels([]int{len(p.types)})
+
+	p.o = calculateOrdering(levels, p.runes)
+	return p.o, nil
 }
 
 // Line computes the visual ordering of runs for a single line starting and
 // ending at the given positions in the original text.
 func (p *Paragraph) Line(start, end int) (Ordering, error) {
-	panic("unimplemented")
+	lineTypes := p.types[start:end]
+	para, err := newParagraph(lineTypes, p.pairTypes[start:end], p.pairValues[start:end], -1)
+	if err != nil {
+		return Ordering{}, err
+	}
+	levels := para.getLevels([]int{len(lineTypes)})
+	o := calculateOrdering(levels, p.runes[start:end])
+	return o, nil
 }
 
 // An Ordering holds the computed visual order of runs of a Paragraph. Calling
 // SetBytes or SetString on the originating Paragraph invalidates an Ordering.
 // The methods of an Ordering should only be called by one goroutine at a time.
-type Ordering struct{}
+type Ordering struct {
+	runes      [][]rune
+	directions []Direction
+	startpos   []int
+}
 
 // Direction reports the directionality of the runs.
 //
 // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral.
 func (o *Ordering) Direction() Direction {
-	panic("unimplemented")
+	return o.directions[0]
 }
 
 // NumRuns returns the number of runs.
 func (o *Ordering) NumRuns() int {
-	panic("unimplemented")
+	return len(o.runes)
 }
 
 // Run returns the ith run within the ordering.
 func (o *Ordering) Run(i int) Run {
-	panic("unimplemented")
+	r := Run{
+		runes:     o.runes[i],
+		direction: o.directions[i],
+		startpos:  o.startpos[i],
+	}
+	return r
 }
 
 // TODO: perhaps with options.
@@ -155,16 +286,19 @@
 
 // A Run is a continuous sequence of characters of a single direction.
 type Run struct {
+	runes     []rune
+	direction Direction
+	startpos  int
 }
 
 // String returns the text of the run in its original order.
 func (r *Run) String() string {
-	panic("unimplemented")
+	return string(r.runes)
 }
 
 // Bytes returns the text of the run in its original order.
 func (r *Run) Bytes() []byte {
-	panic("unimplemented")
+	return []byte(r.String())
 }
 
 // TODO: methods for
@@ -174,25 +308,52 @@
 
 // Direction reports the direction of the run.
 func (r *Run) Direction() Direction {
-	panic("unimplemented")
+	return r.direction
 }
 
-// Position of the Run within the text passed to SetBytes or SetString of the
+// Pos returns the position of the Run within the text passed to SetBytes or SetString of the
 // originating Paragraph value.
 func (r *Run) Pos() (start, end int) {
-	panic("unimplemented")
+	return r.startpos, r.startpos + len(r.runes) - 1
 }
 
 // AppendReverse reverses the order of characters of in, appends them to out,
 // and returns the result. Modifiers will still follow the runes they modify.
 // Brackets are replaced with their counterparts.
 func AppendReverse(out, in []byte) []byte {
-	panic("unimplemented")
+	ret := make([]byte, len(in)+len(out))
+	copy(ret, out)
+	inRunes := bytes.Runes(in)
+
+	for i, r := range inRunes {
+		prop, _ := LookupRune(r)
+		if prop.IsBracket() {
+			inRunes[i] = prop.reverseBracket(r)
+		}
+	}
+
+	for i, j := 0, len(inRunes)-1; i < j; i, j = i+1, j-1 {
+		inRunes[i], inRunes[j] = inRunes[j], inRunes[i]
+	}
+	copy(ret[len(out):], string(inRunes))
+
+	return ret
 }
 
 // ReverseString reverses the order of characters in s and returns a new string.
 // Modifiers will still follow the runes they modify. Brackets are replaced with
 // their counterparts.
 func ReverseString(s string) string {
-	panic("unimplemented")
+	input := []rune(s)
+	li := len(input)
+	ret := make([]rune, li)
+	for i, r := range input {
+		prop, _ := LookupRune(r)
+		if prop.IsBracket() {
+			ret[li-i-1] = prop.reverseBracket(r)
+		} else {
+			ret[li-i-1] = r
+		}
+	}
+	return string(ret)
 }
diff --git a/unicode/bidi/bidi_test.go b/unicode/bidi/bidi_test.go
new file mode 100644
index 0000000..88572f5
--- /dev/null
+++ b/unicode/bidi/bidi_test.go
@@ -0,0 +1,347 @@
+package bidi
+
+import (
+	"log"
+	"testing"
+)
+
+type runInformation struct {
+	str   string
+	dir   Direction
+	start int
+	end   int
+}
+
+func TestSimple(t *testing.T) {
+	str := "Hellö"
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	expectedRuns := []runInformation{
+		{"Hellö", LeftToRight, 0, 4},
+	}
+
+	if !p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == false; want true")
+	}
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start %d, end %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestMixed(t *testing.T) {
+	str := `العاشر ليونيكود (Unicode Conference)، الذي سيعقد في 10-12 آذار 1997 مبدينة`
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == true; want false")
+	}
+
+	expectedRuns := []runInformation{
+		{"العاشر ليونيكود (", RightToLeft, 0, 16},
+		{"Unicode Conference", LeftToRight, 17, 34},
+		{")، الذي سيعقد في ", RightToLeft, 35, 51},
+		{"10", LeftToRight, 52, 53},
+		{"-", RightToLeft, 54, 54},
+		{"12", LeftToRight, 55, 56},
+		{" آذار ", RightToLeft, 57, 62},
+		{"1997", LeftToRight, 63, 66},
+		{" مبدينة", RightToLeft, 67, 73},
+	}
+
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start = %d, end = %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestExplicitIsolate(t *testing.T) {
+	// https://www.w3.org/International/articles/inline-bidi-markup/uba-basics.en#beyond
+	str := "The names of these states in Arabic are \u2067مصر\u2069, \u2067البحرين\u2069 and \u2067الكويت\u2069 respectively."
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == false; want true")
+	}
+
+	expectedRuns := []runInformation{
+		{"The names of these states in Arabic are \u2067", LeftToRight, 0, 40},
+		{"مصر", RightToLeft, 41, 43},
+		{"\u2069, \u2067", LeftToRight, 44, 47},
+		{"البحرين", RightToLeft, 48, 54},
+		{"\u2069 and \u2067", LeftToRight, 55, 61},
+		{"الكويت", RightToLeft, 62, 67},
+		{"\u2069 respectively.", LeftToRight, 68, 82},
+	}
+
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start = %d, end = %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestWithoutExplicitIsolate(t *testing.T) {
+	str := "The names of these states in Arabic are مصر, البحرين and الكويت respectively."
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == false; want true")
+	}
+
+	expectedRuns := []runInformation{
+		{"The names of these states in Arabic are ", LeftToRight, 0, 39},
+		{"مصر, البحرين", RightToLeft, 40, 51},
+		{" and ", LeftToRight, 52, 56},
+		{"الكويت", RightToLeft, 57, 62},
+		{" respectively.", LeftToRight, 63, 76},
+	}
+
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start = %d, end = %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestLongUTF8(t *testing.T) {
+	str := `𠀀`
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == false; want true")
+	}
+
+	expectedRuns := []runInformation{
+		{"𠀀", LeftToRight, 0, 0},
+	}
+
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start = %d, end = %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestLLongUTF8(t *testing.T) {
+	strTester := []struct {
+		str string
+		l   int
+	}{
+		{"ö", 2},
+		{"ॡ", 3},
+		{`𠀀`, 4},
+	}
+	for _, st := range strTester {
+		str := st.str
+		want := st.l
+		if _, l := LookupString(str); l != want {
+			t.Errorf("LookupString(%q) length = %d; want %d", str, l, want)
+		}
+
+	}
+
+}
+
+func TestMixedSimple(t *testing.T) {
+	str := `Uا`
+	p := Paragraph{}
+	p.SetString(str)
+	order, err := p.Order()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if !p.IsLeftToRight() {
+		t.Error("p.IsLeftToRight() == false; want true")
+	}
+
+	expectedRuns := []runInformation{
+		{"U", LeftToRight, 0, 0},
+		{"ا", RightToLeft, 1, 1},
+	}
+
+	if nr, want := order.NumRuns(), len(expectedRuns); nr != want {
+		t.Errorf("order.NumRuns() = %d; want %d", nr, want)
+	}
+
+	for i, want := range expectedRuns {
+		r := order.Run(i)
+		if got := r.String(); got != want.str {
+			t.Errorf("Run(%d) = %q; want %q", i, got, want.str)
+		}
+		if s, e := r.Pos(); s != want.start || e != want.end {
+			t.Errorf("Run(%d).start = %d, .end = %d; want start = %d, end = %d", i, s, e, want.start, want.end)
+		}
+		if d := r.Direction(); d != want.dir {
+			t.Errorf("Run(%d).Direction = %d; want %d", i, d, want.dir)
+		}
+	}
+}
+
+func TestDefaultDirection(t *testing.T) {
+	str := "+"
+	p := Paragraph{}
+	p.SetString(str, DefaultDirection(RightToLeft))
+	_, err := p.Order()
+	if err != nil {
+		t.Error(err)
+		t.Fail()
+	}
+	if want, dir := false, p.IsLeftToRight(); want != dir {
+		t.Errorf("p.IsLeftToRight() = %t; want %t", dir, want)
+	}
+	p.SetString(str, DefaultDirection(LeftToRight))
+	_, err = p.Order()
+	if err != nil {
+		t.Error(err)
+		t.Fail()
+	}
+	if want, dir := true, p.IsLeftToRight(); want != dir {
+		t.Errorf("p.IsLeftToRight() = %t; want %t", dir, want)
+	}
+
+}
+
+func TestEmpty(t *testing.T) {
+	p := Paragraph{}
+	p.SetBytes([]byte{})
+	o, err := p.Order()
+	if err != nil {
+		t.Error("p.Order() return err != nil; want err == nil")
+	}
+	if nr := o.NumRuns(); nr != 0 {
+		t.Errorf("o.NumRuns() = %d; want 0", nr)
+	}
+}
+
+func TestNewline(t *testing.T) {
+	str := "Hello\nworld"
+	p := Paragraph{}
+	n, err := p.SetString(str)
+	if err != nil {
+		t.Error(err)
+	}
+	// 6 is the length up to and including the \n
+	if want := 6; n != want {
+		t.Errorf("SetString(%q) = nil, %d; want nil, %d", str, n, want)
+	}
+}
+
+func TestDoubleSetString(t *testing.T) {
+	str := "العاشر ليونيكود (Unicode Conference)،"
+	p := Paragraph{}
+	_, err := p.SetString(str)
+	if err != nil {
+		t.Error(err)
+	}
+	_, err = p.SetString(str)
+	if err != nil {
+		t.Error(err)
+	}
+	_, err = p.Order()
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestReverseString(t *testing.T) {
+	input := "(Hello)"
+	want := "(olleH)"
+	if str := ReverseString(input); str != want {
+		t.Errorf("ReverseString(%s) = %q; want %q", input, str, want)
+	}
+}
+
+func TestAppendReverse(t *testing.T) {
+	testcase := []struct {
+		inString  string
+		outString string
+		want      string
+	}{
+		{"", "Hëllo", "Hëllo"},
+		{"nice (wörld)", "", "(dlröw) ecin"},
+		{"nice (wörld)", "Hëllo", "Hëllo(dlröw) ecin"},
+	}
+	for _, tc := range testcase {
+		if r := AppendReverse([]byte(tc.outString), []byte(tc.inString)); string(r) != tc.want {
+			t.Errorf("AppendReverse([]byte(%q), []byte(%q) = %q; want %q", tc.outString, tc.inString, string(r), tc.want)
+		}
+	}
+
+}
diff --git a/unicode/bidi/core.go b/unicode/bidi/core.go
index 50deb66..e4c0811 100644
--- a/unicode/bidi/core.go
+++ b/unicode/bidi/core.go
@@ -4,7 +4,10 @@
 
 package bidi
 
-import "log"
+import (
+	"fmt"
+	"log"
+)
 
 // This implementation is a port based on the reference implementation found at:
 // https://www.unicode.org/Public/PROGRAMS/BidiReferenceJava/
@@ -97,13 +100,20 @@
 // rune (suggested is the rune of the open bracket for opening and matching
 // close brackets, after normalization). The embedding levels are optional, but
 // may be supplied to encode embedding levels of styled text.
-//
-// TODO: return an error.
-func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, levels level) *paragraph {
-	validateTypes(types)
-	validatePbTypes(pairTypes)
-	validatePbValues(pairValues, pairTypes)
-	validateParagraphEmbeddingLevel(levels)
+func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, levels level) (*paragraph, error) {
+	var err error
+	if err = validateTypes(types); err != nil {
+		return nil, err
+	}
+	if err = validatePbTypes(pairTypes); err != nil {
+		return nil, err
+	}
+	if err = validatePbValues(pairValues, pairTypes); err != nil {
+		return nil, err
+	}
+	if err = validateParagraphEmbeddingLevel(levels); err != nil {
+		return nil, err
+	}
 
 	p := &paragraph{
 		initialTypes:   append([]Class(nil), types...),
@@ -115,7 +125,7 @@
 		resultTypes: append([]Class(nil), types...),
 	}
 	p.run()
-	return p
+	return p, nil
 }
 
 func (p *paragraph) Len() int { return len(p.initialTypes) }
@@ -1001,58 +1011,61 @@
 	return R
 }
 
-// TODO: change validation to not panic
-
-func validateTypes(types []Class) {
+func validateTypes(types []Class) error {
 	if len(types) == 0 {
-		log.Panic("types is null")
+		return fmt.Errorf("types is null")
 	}
 	for i, t := range types[:len(types)-1] {
 		if t == B {
-			log.Panicf("B type before end of paragraph at index: %d", i)
+			return fmt.Errorf("B type before end of paragraph at index: %d", i)
 		}
 	}
+	return nil
 }
 
-func validateParagraphEmbeddingLevel(embeddingLevel level) {
+func validateParagraphEmbeddingLevel(embeddingLevel level) error {
 	if embeddingLevel != implicitLevel &&
 		embeddingLevel != 0 &&
 		embeddingLevel != 1 {
-		log.Panicf("illegal paragraph embedding level: %d", embeddingLevel)
+		return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
 	}
+	return nil
 }
 
-func validateLineBreaks(linebreaks []int, textLength int) {
+func validateLineBreaks(linebreaks []int, textLength int) error {
 	prev := 0
 	for i, next := range linebreaks {
 		if next <= prev {
-			log.Panicf("bad linebreak: %d at index: %d", next, i)
+			return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
 		}
 		prev = next
 	}
 	if prev != textLength {
-		log.Panicf("last linebreak was %d, want %d", prev, textLength)
+		return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
 	}
+	return nil
 }
 
-func validatePbTypes(pairTypes []bracketType) {
+func validatePbTypes(pairTypes []bracketType) error {
 	if len(pairTypes) == 0 {
-		log.Panic("pairTypes is null")
+		return fmt.Errorf("pairTypes is null")
 	}
 	for i, pt := range pairTypes {
 		switch pt {
 		case bpNone, bpOpen, bpClose:
 		default:
-			log.Panicf("illegal pairType value at %d: %v", i, pairTypes[i])
+			return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
 		}
 	}
+	return nil
 }
 
-func validatePbValues(pairValues []rune, pairTypes []bracketType) {
+func validatePbValues(pairValues []rune, pairTypes []bracketType) error {
 	if pairValues == nil {
-		log.Panic("pairValues is null")
+		return fmt.Errorf("pairValues is null")
 	}
 	if len(pairTypes) != len(pairValues) {
-		log.Panic("pairTypes is different length from pairValues")
+		return fmt.Errorf("pairTypes is different length from pairValues")
 	}
+	return nil
 }
diff --git a/unicode/bidi/core_test.go b/unicode/bidi/core_test.go
index b653399..1c928af 100644
--- a/unicode/bidi/core_test.go
+++ b/unicode/bidi/core_test.go
@@ -55,7 +55,10 @@
 				continue
 			}
 			lev := level(int(i) - 1)
-			par := newParagraph(types, pairTypes, pairValues, lev)
+			par, err := newParagraph(types, pairTypes, pairValues, lev)
+			if err != nil {
+				t.Error(err)
+			}
 
 			if *testLevels {
 				levels := par.getLevels([]int{len(types)})
@@ -142,7 +145,10 @@
 				pairValues = append(pairValues, p.reverseBracket(r))
 			}
 		}
-		par := newParagraph(types, pairTypes, pairValues, parLevel)
+		par, err := newParagraph(types, pairTypes, pairValues, parLevel)
+		if err != nil {
+			t.Error(err)
+		}
 
 		// Test results:
 		if got := par.embeddingLevel; got != wantLevel {