Index: uspace/app/bithenge/linux/os.h
===================================================================
--- uspace/app/bithenge/linux/os.h	(revision 03b2b2c641e73ecbc2828da79253cb7dd68e6062)
+++ uspace/app/bithenge/linux/os.h	(revision 0d1a8fd13c2080836b202a79f4c1de55f2044547)
@@ -85,4 +85,9 @@
 }
 
+static inline char *str_dup(const char *s)
+{
+	return strdup(s);
+}
+
 static inline char *str_ndup(const char *s, size_t max_len)
 {
@@ -100,3 +105,8 @@
 }
 
+static inline uint32_t uint32_t_be2host(uint32_t val)
+{
+	return be32toh(val);
+}
+
 #endif
Index: uspace/app/bithenge/script.c
===================================================================
--- uspace/app/bithenge/script.c	(revision 03b2b2c641e73ecbc2828da79253cb7dd68e6062)
+++ uspace/app/bithenge/script.c	(revision 0d1a8fd13c2080836b202a79f4c1de55f2044547)
@@ -232,12 +232,23 @@
 }
 
-/** Find a transform by name.
+/** Find a transform by name. A reference will be added to the transform.
  * @return The found transform, or NULL if none was found. */
 static bithenge_transform_t *get_named_transform(state_t *state,
     const char *name)
 {
-	for (transform_list_t *e = state->transform_list; e; e = e->next)
-		if (!str_cmp(e->name, name))
+	for (transform_list_t *e = state->transform_list; e; e = e->next) {
+		if (!str_cmp(e->name, name)) {
+			bithenge_transform_inc_ref(e->transform);
 			return e->transform;
+		}
+	}
+	for (int i = 0; bithenge_primitive_transforms[i].name; i++) {
+		if (!str_cmp(bithenge_primitive_transforms[i].name, name)) {
+			bithenge_transform_t *xform =
+			    bithenge_primitive_transforms[i].transform;
+			bithenge_transform_inc_ref(xform);
+			return xform;
+		}
+	}
 	return NULL;
 }
Index: uspace/app/bithenge/transform.c
===================================================================
--- uspace/app/bithenge/transform.c	(revision 03b2b2c641e73ecbc2828da79253cb7dd68e6062)
+++ uspace/app/bithenge/transform.c	(revision 0d1a8fd13c2080836b202a79f4c1de55f2044547)
@@ -35,5 +35,7 @@
  */
 
+#include <assert.h>
 #include <errno.h>
+#include <stdlib.h>
 #include "blob.h"
 #include "transform.h"
@@ -41,5 +43,6 @@
 static int transform_indestructible(bithenge_transform_t *xform)
 {
-	return EINVAL;
+	assert(false);
+	return EOK;
 }
 
@@ -64,6 +67,26 @@
 }
 
-static int uint32le_prefix_length(bithenge_transform_t *xform,
-    bithenge_blob_t *blob, aoff64_t *out)
+static int uint32be_apply(bithenge_transform_t *xform, bithenge_node_t *in,
+    bithenge_node_t **out)
+{
+	int rc;
+	if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
+		return EINVAL;
+	bithenge_blob_t *blob = bithenge_node_as_blob(in);
+
+	// Try to read 5 bytes and fail if the blob is too long.
+	uint32_t val[2];
+	aoff64_t size = sizeof(val[0]) + 1;
+	rc = bithenge_blob_read(blob, 0, (char *)val, &size);
+	if (rc != EOK)
+		return rc;
+	if (size != 4)
+		return EINVAL;
+
+	return bithenge_new_integer_node(out, uint32_t_be2host(val[0]));
+}
+
+static int prefix_length_4(bithenge_transform_t *xform, bithenge_blob_t *blob,
+    aoff64_t *out)
 {
 	*out = 4;
@@ -73,20 +96,32 @@
 static const bithenge_transform_ops_t uint32le_ops = {
 	.apply = uint32le_apply,
-	.prefix_length = uint32le_prefix_length,
+	.prefix_length = prefix_length_4,
 	.destroy = transform_indestructible,
 };
 
-static bithenge_transform_t uint32le_transform = {
+static const bithenge_transform_ops_t uint32be_ops = {
+	.apply = uint32be_apply,
+	.prefix_length = prefix_length_4,
+	.destroy = transform_indestructible,
+};
+
+/** The little-endian 32-bit unsigned integer transform. */
+bithenge_transform_t bithenge_uint32le_transform = {
 	&uint32le_ops, 1
 };
 
-/** Create a little-endian 32-bit unsigned integer transform.
- * @param out Holds the transform.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_uint32le_transform(bithenge_transform_t **out)
-{
-	*out = &uint32le_transform;
-	return EOK;
-}
+/** The big-endian 32-bit unsigned integer transform. */
+bithenge_transform_t bithenge_uint32be_transform = {
+	&uint32be_ops, 1
+};
+
+static bithenge_named_transform_t primitive_transforms[] = {
+	{"uint32le", &bithenge_uint32le_transform},
+	{"uint32be", &bithenge_uint32be_transform},
+	{NULL, NULL}
+};
+
+/** An array of named built-in transforms. */
+bithenge_named_transform_t *bithenge_primitive_transforms = primitive_transforms;
 
 /** @}
Index: uspace/app/bithenge/transform.h
===================================================================
--- uspace/app/bithenge/transform.h	(revision 03b2b2c641e73ecbc2828da79253cb7dd68e6062)
+++ uspace/app/bithenge/transform.h	(revision 0d1a8fd13c2080836b202a79f4c1de55f2044547)
@@ -117,5 +117,13 @@
 }
 
-int bithenge_uint32le_transform(bithenge_transform_t **out);
+/** A transform with a name. */
+typedef struct {
+	const char *name;
+	bithenge_transform_t *transform;
+} bithenge_named_transform_t;
+
+extern bithenge_transform_t bithenge_uint32le_transform;
+extern bithenge_transform_t bithenge_uint32be_transform;
+extern bithenge_named_transform_t *bithenge_primitive_transforms;
 
 #endif