diff --git a/Cargo.toml b/Cargo.toml
index ad03b3b2..113e9a03 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,6 +34,8 @@ base64 = "0.13"
 hex = "0.4"
 regex = "1.5"
 lru = "0.10"
+urlencoding = "2.1.2"
+dyn-clone = "1.0.11"
 
 [dev-dependencies]
 tempfile = "3.1"
diff --git a/benches/bench.rs b/benches/bench.rs
index e5522071..f86c2ceb 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -4,12 +4,13 @@ extern crate test;
 use tempfile::tempdir;
 use terminus_store;
 use terminus_store::layer::ValueTriple;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use test::Bencher;
 
 #[bench]
 fn bench_add_string_triple(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let sync_store = terminus_store::open_sync_directory_store(dir.path());
+    let sync_store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let layer_builder = sync_store.create_base_layer().unwrap();
     let mut count = 1;
     b.iter(|| {
diff --git a/benches/builder/main.rs b/benches/builder/main.rs
index 9557c93b..63a48a41 100644
--- a/benches/builder/main.rs
+++ b/benches/builder/main.rs
@@ -5,6 +5,7 @@ mod data;
 use rand::prelude::*;
 use tempfile::tempdir;
 use terminus_store;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use test::Bencher;
 
 use data::*;
@@ -12,7 +13,7 @@ use data::*;
 #[bench]
 fn build_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     b.iter(|| {
         let builder = store.create_base_layer().unwrap();
@@ -23,7 +24,7 @@ fn build_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_base_layer_1000(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
@@ -48,7 +49,7 @@ fn build_base_layer_1000(b: &mut Bencher) {
 #[bench]
 fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -61,7 +62,7 @@ fn build_empty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
     let builder = store.create_base_layer().unwrap();
     let base_layer = builder.commit().unwrap();
 
@@ -88,7 +89,7 @@ fn build_nonempty_child_layer_on_empty_base_layer(b: &mut Bencher) {
 #[bench]
 fn build_nonempty_child_layer_on_nonempty_base_layer(b: &mut Bencher) {
     let dir = tempdir().unwrap();
-    let store = terminus_store::open_sync_directory_store(dir.path());
+    let store = terminus_store::open_sync_directory_store(dir.path(), NoFilenameEncoding);
 
     let seed = b"the quick brown fox jumped over ";
     let rand = StdRng::from_seed(*seed);
diff --git a/examples/create_graph.rs b/examples/create_graph.rs
index fba7644f..7bbacedc 100644
--- a/examples/create_graph.rs
+++ b/examples/create_graph.rs
@@ -1,5 +1,6 @@
 use std::env;
 
+use terminus_store::storage::directory::NoFilenameEncoding;
 use terminus_store::*;
 use tokio;
 
@@ -10,7 +11,7 @@ async fn main() {
         println!("usage: {} <path> <graph_name>", args[0]);
     } else {
         // open a store at the given path. the directory has to exist.
-        let store = open_directory_store(&args[1]);
+        let store = open_directory_store(&args[1], NoFilenameEncoding);
 
         // then create a graph. if the graph already exists, this will error.
         store.create(&args[2]).await.unwrap();
diff --git a/examples/print_graph.rs b/examples/print_graph.rs
index 85513e91..ae07b1a3 100644
--- a/examples/print_graph.rs
+++ b/examples/print_graph.rs
@@ -1,12 +1,13 @@
 use std::env;
 
 use std::io;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use terminus_store::structure::TdbDataType;
 use terminus_store::*;
 use tokio;
 
 async fn print_graph(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path);
+    let store = open_directory_store(store_path, NoFilenameEncoding);
     let graph = store
         .open(graph)
         .await?
diff --git a/examples/write_to_graph.rs b/examples/write_to_graph.rs
index 5a67ceb6..cb68507d 100644
--- a/examples/write_to_graph.rs
+++ b/examples/write_to_graph.rs
@@ -2,6 +2,7 @@ use std::env;
 
 use lazy_static::lazy_static;
 use regex::Regex;
+use terminus_store::storage::directory::NoFilenameEncoding;
 use terminus_store::*;
 use tokio;
 use tokio::io::{self, AsyncBufReadExt};
@@ -52,7 +53,7 @@ async fn parse_command(s: &str) -> io::Result<Command> {
 }
 
 async fn process_commands(store_path: &str, graph: &str) -> io::Result<()> {
-    let store = open_directory_store(store_path);
+    let store = open_directory_store(store_path, NoFilenameEncoding);
     let graph = store
         .open(graph)
         .await?
diff --git a/src/storage/directory.rs b/src/storage/directory.rs
index 54702adc..bb5e0c4f 100644
--- a/src/storage/directory.rs
+++ b/src/storage/directory.rs
@@ -1,6 +1,7 @@
 //! Directory-based implementation of storage traits.
 
 use bytes::{Bytes, BytesMut};
+use dyn_clone::{clone_trait_object, DynClone};
 use locking::*;
 use std::collections::HashMap;
 use std::io::{self, SeekFrom};
@@ -9,6 +10,7 @@ use std::sync::Arc;
 use tokio::fs::{self, *};
 use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufWriter};
 use tokio::sync::RwLock;
+use urlencoding::{decode, encode};
 
 use async_trait::async_trait;
 
@@ -181,14 +183,55 @@ impl PersistentLayerStore for DirectoryLayerStore {
     }
 }
 
+/// Encoding of the file names
+pub trait FilenameEncoding: DynClone + Send + Sync {
+    fn encode(&self, str: String) -> String;
+    fn decode(&self, str: String) -> String;
+}
+
+clone_trait_object!(FilenameEncoding);
+
+/// Bypassing encoding of the file name
+#[derive(Clone)]
+pub struct NoFilenameEncoding;
+
+impl FilenameEncoding for NoFilenameEncoding {
+    fn encode(&self, str: String) -> String {
+        str
+    }
+    fn decode(&self, str: String) -> String {
+        str
+    }
+}
+
+/// URL encoding of the file name
+#[derive(Clone)]
+pub struct URLFilenameEncoding;
+
+impl FilenameEncoding for URLFilenameEncoding {
+    fn encode(&self, str: String) -> String {
+        return encode(str.as_str()).to_string();
+    }
+    fn decode(&self, str: String) -> String {
+        return decode(str.as_str()).unwrap().to_string();
+    }
+}
+
 #[derive(Clone)]
 pub struct DirectoryLabelStore {
     path: PathBuf,
+    filename_encoding: Box<dyn FilenameEncoding>,
 }
 
 impl DirectoryLabelStore {
-    pub fn new<P: Into<PathBuf>>(path: P) -> DirectoryLabelStore {
-        DirectoryLabelStore { path: path.into() }
+    pub fn new<P: Into<PathBuf>>(
+        path: P,
+        filename_encoding: impl FilenameEncoding + 'static,
+    ) -> DirectoryLabelStore {
+        DirectoryLabelStore {
+            path: path.into(),
+            filename_encoding: Box::new(filename_encoding),
+        }
     }
 }
 
@@ -235,28 +278,27 @@ fn get_label_from_data(name: String, data: &[u8]) -> io::Result<Label> {
     }
 }
 
-async fn get_label_from_file<P: Into<PathBuf>>(path: P) -> io::Result<Label> {
+async fn get_label_from_file<P: Into<PathBuf>>(path: P, name: String) -> io::Result<Label> {
     let path: PathBuf = path.into();
-    let label = path.file_stem().unwrap().to_str().unwrap().to_owned();
 
     let mut file = LockedFile::open(path).await?;
     let mut data = Vec::new();
     file.read_to_end(&mut data).await?;
 
-    get_label_from_data(label, &data)
+    get_label_from_data(name, &data)
 }
 
 async fn get_label_from_exclusive_locked_file<P: Into<PathBuf>>(
     path: P,
+    name: String,
 ) -> io::Result<(Label, ExclusiveLockedFile)> {
     let path: PathBuf = path.into();
-    let label = path.file_stem().unwrap().to_str().unwrap().to_owned();
 
     let mut file = ExclusiveLockedFile::open(path).await?;
     let mut data = Vec::new();
     file.read_to_end(&mut data).await?;
 
-    let label = get_label_from_data(label, &data)?;
+    let label = get_label_from_data(name, &data)?;
     file.seek(SeekFrom::Start(0)).await?;
 
     Ok((label, file))
@@ -277,7 +319,19 @@ impl LabelStore for DirectoryLabelStore {
                     )
                 })?;
                 if name.ends_with(".label") {
-                    let label = get_label_from_file(direntry.path()).await?;
+                    let label = get_label_from_file(
+                        direntry.path(),
+                        self.filename_encoding.decode(
+                            direntry
+                                .path()
+                                .file_stem()
+                                .unwrap()
+                                .to_str()
+                                .unwrap()
+                                .to_owned(),
+                        ),
+                    )
+                    .await?;
                     result.push(label);
                 }
             }
@@ -288,7 +342,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn create_label(&self, label: &str) -> io::Result<Label> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label));
+        p.push(self.filename_encoding.encode(format!("{}.label", label)));
         let contents = "0\n\n".to_string().into_bytes();
         match fs::metadata(&p).await {
             Ok(_) => Err(io::Error::new(
@@ -311,9 +365,9 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn get_label(&self, label: &str) -> io::Result<Option<Label>> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label));
+        p.push(self.filename_encoding.encode(format!("{}.label", label)));
 
-        match get_label_from_file(p).await {
+        match get_label_from_file(p, label.to_owned()).await {
             Ok(label) => Ok(Some(label)),
             Err(e) => match e.kind() {
                 io::ErrorKind::NotFound => Ok(None),
@@ -336,8 +390,12 @@ impl LabelStore for DirectoryLabelStore {
         };
 
         let mut p = self.path.clone();
-        p.push(format!("{}.label", label.name));
-        let (retrieved_label, mut file) = get_label_from_exclusive_locked_file(p).await?;
+        p.push(
+            self.filename_encoding
+                .encode(format!("{}.label", label.name)),
+        );
+        let (retrieved_label, mut file) =
+            get_label_from_exclusive_locked_file(p, label.name.clone()).await?;
         if retrieved_label == *label {
             // all good, let's a go
             file.truncate().await?;
@@ -352,7 +410,7 @@ impl LabelStore for DirectoryLabelStore {
 
     async fn delete_label(&self, name: &str) -> io::Result<bool> {
         let mut p = self.path.clone();
-        p.push(format!("{}.label", name));
+        p.push(self.filename_encoding.encode(format!("{}.label", name)));
 
         // We're not locking here to remove the file. The assumption
         // is that any concurrent operation that is done on the label
@@ -384,6 +442,7 @@ impl LabelStore for DirectoryLabelStore {
 pub struct CachedDirectoryLabelStore {
     path: PathBuf,
     labels: Arc<RwLock<HashMap<String, Label>>>,
+    filename_encoding: Box<dyn FilenameEncoding>,
 }
 
 impl CachedDirectoryLabelStore {
@@ -391,38 +450,38 @@ impl CachedDirectoryLabelStore {
     ///
     /// This will read in all label files on startup, which is why
     /// this is an async operation.
-    pub async fn open<P: Into<PathBuf>>(path: P) -> io::Result<Self> {
+    pub async fn open<P: Into<PathBuf>>(
+        path: P,
+        filename_encoding: impl FilenameEncoding + 'static,
+    ) -> io::Result<Self> {
         let path: PathBuf = path.into();
-        let labels = get_all_labels_from_dir(&path).await?;
+        let mut labels = HashMap::new();
+        let mut entries = tokio::fs::read_dir(&path).await?;
 
-        Ok(Self {
-            path,
-            labels: Arc::new(RwLock::new(labels)),
-        })
-    }
-}
-
-async fn get_all_labels_from_dir(p: &PathBuf) -> io::Result<HashMap<String, Label>> {
-    let mut result = HashMap::new();
-    let mut entries = tokio::fs::read_dir(p).await?;
-
-    while let Some(entry) = entries.next_entry().await? {
-        if !entry.file_type().await?.is_file() {
-            continue;
-        }
-        if let Ok(file_name) = entry.file_name().into_string() {
-            if !file_name.ends_with(".label") {
+        while let Some(entry) = entries.next_entry().await? {
+            if !entry.file_type().await?.is_file() {
                 continue;
             }
+            if let Ok(file_name) = entry.file_name().into_string() {
+                if !file_name.ends_with(".label") {
+                    continue;
+                }
 
-            let label_name = file_name[..file_name.len() - 6].to_string();
-            let label = get_label_from_file(entry.path()).await?;
+                let label_name = file_name[..file_name.len() - 6].to_string();
+                let label =
+                    get_label_from_file(entry.path(), filename_encoding.decode(label_name.clone()))
+                        .await?;
 
-            result.insert(label_name, label);
+                labels.insert(label_name, label);
+            }
         }
-    }
 
-    Ok(result)
+        Ok(Self {
+            path,
+            labels: Arc::new(RwLock::new(labels)),
+            filename_encoding: Box::new(filename_encoding),
+        })
+    }
 }
 
 #[async_trait]
@@ -490,7 +549,10 @@ impl LabelStore for CachedDirectoryLabelStore {
             if retrieved_label == label {
                 // all good, let's a go
                 let mut p = self.path.clone();
-                p.push(format!("{}.label", label.name));
+                p.push(
+                    self.filename_encoding
+                        .encode(format!("{}.label", label.name)),
+                );
                 let mut options = fs::OpenOptions::new();
                 options.create(false);
                 options.write(true);
@@ -513,7 +575,7 @@ impl LabelStore for CachedDirectoryLabelStore {
         let mut labels = self.labels.write().await;
         if labels.remove(name).is_some() {
             let mut p = self.path.clone();
-            p.push(format!("{}.label", name));
+            p.push(self.filename_encoding.encode(format!("{}.label", name)));
             tokio::fs::remove_file(p).await?;
 
             Ok(true)
@@ -623,7 +685,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_and_retrieve_equal_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let (stored, retrieved) = async {
             let stored = store.create_label("foo").await?;
@@ -638,10 +700,32 @@ mod tests {
         assert_eq!(stored, retrieved.unwrap());
     }
 
+    #[tokio::test]
+    async fn directory_create_and_retrieve_equal_url_label() {
+        let dir = tempdir().unwrap();
+        let store = DirectoryLabelStore::new(dir.path(), URLFilenameEncoding);
+
+        let (stored, retrieved) = async {
+            let stored = store
+                .create_label("https://terminusdb.com/?s=does+work")
+                .await?;
+            let retrieved = store
+                .get_label("https://terminusdb.com/?s=does+work")
+                .await?;
+
+            Ok::<_, io::Error>((stored, retrieved))
+        }
+        .await
+        .unwrap();
+
+        assert_eq!(None, stored.layer);
+        assert_eq!(stored, retrieved.unwrap());
+    }
+
     #[tokio::test]
     async fn directory_update_label_succeeds() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let retrieved = async {
             let stored = store.create_label("foo").await?;
@@ -659,7 +743,7 @@ mod tests {
     #[tokio::test]
     async fn directory_update_label_twice_from_same_label_object_fails() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         let (stored2, stored3) = async {
             let stored1 = store.create_label("foo").await?;
@@ -679,7 +763,7 @@ mod tests {
     #[tokio::test]
     async fn directory_create_label_twice_errors() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let result = store.create_label("foo").await;
@@ -799,7 +883,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_delete_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         assert!(store.get_label("foo").await.unwrap().is_some());
@@ -810,7 +894,7 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         assert!(!store.delete_label("foo").await.unwrap());
     }
@@ -818,7 +902,7 @@ mod tests {
     #[tokio::test]
     async fn delete_shared_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
@@ -830,7 +914,7 @@ mod tests {
     #[tokio::test]
     async fn delete_exclusive_locked_label() {
         let dir = tempdir().unwrap();
-        let store = DirectoryLabelStore::new(dir.path());
+        let store = DirectoryLabelStore::new(dir.path(), NoFilenameEncoding);
 
         store.create_label("foo").await.unwrap();
         let label_path = dir.path().join("foo.label");
diff --git a/src/storage/pack.rs b/src/storage/pack.rs
index 88002a8e..3446e82a 100644
--- a/src/storage/pack.rs
+++ b/src/storage/pack.rs
@@ -19,7 +19,7 @@ use tokio::io::AsyncWriteExt;
 
 #[async_trait]
 pub trait Packable {
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     async fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,
diff --git a/src/store/mod.rs b/src/store/mod.rs
index 3c776171..f8df9fb1 100644
--- a/src/store/mod.rs
+++ b/src/store/mod.rs
@@ -10,7 +10,7 @@ use crate::layer::{IdTriple, Layer, LayerBuilder, LayerCounts, ObjectType, Value
 use crate::storage::archive::{
     ArchiveLayerStore, DirectoryArchiveBackend, LruArchiveBackend, LruMetadataArchiveBackend,
 };
-use crate::storage::directory::{DirectoryLabelStore, DirectoryLayerStore};
+use crate::storage::directory::{DirectoryLabelStore, DirectoryLayerStore, FilenameEncoding};
 use crate::storage::memory::{MemoryLabelStore, MemoryLayerStore};
 use crate::storage::{CachedLayerStore, LabelStore, LayerStore, LockingHashMapLayerCache};
 use crate::structure::TypedDictEntry;
@@ -873,7 +873,7 @@ impl Store {
         StoreLayerBuilder::new(self.clone()).await
     }
 
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     pub async fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,
@@ -907,17 +907,26 @@ pub fn open_memory_store() -> Store {
 
 /// Open a store that stores its data in the given directory as archive files.
 ///
-/// cache_size specifies in megabytes how large the LRU cache should
+/// * `cache_size` - specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> Store {
+/// * `filename_encoding` - specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_archive_store<P: Into<PathBuf>>(
+    path: P,
+    cache_size: usize,
+    filename_encoding: impl FilenameEncoding + 'static,
+) -> Store {
     let p = path.into();
     let directory_archive_backend = DirectoryArchiveBackend::new(p.clone());
     let archive_backend = LruArchiveBackend::new(directory_archive_backend.clone(), cache_size);
     let archive_metadata_backend =
         LruMetadataArchiveBackend::new(directory_archive_backend, archive_backend.clone());
     Store::new(
-        DirectoryLabelStore::new(p),
+        DirectoryLabelStore::new(p, filename_encoding),
         CachedLayerStore::new(
             ArchiveLayerStore::new(archive_metadata_backend, archive_backend),
             LockingHashMapLayerCache::new(),
@@ -926,10 +935,19 @@ pub fn open_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> Store
 }
 
 /// Open a store that stores its data in the given directory.
-pub fn open_directory_store<P: Into<PathBuf>>(path: P) -> Store {
+///
+/// * `filename_encoding` -  specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_directory_store<P: Into<PathBuf>>(
+    path: P,
+    filename_encoding: impl FilenameEncoding + 'static,
+) -> Store {
     let p = path.into();
     Store::new(
-        DirectoryLabelStore::new(p.clone()),
+        DirectoryLabelStore::new(p.clone(), filename_encoding),
         CachedLayerStore::new(DirectoryLayerStore::new(p), LockingHashMapLayerCache::new()),
     )
 }
@@ -937,6 +955,7 @@ pub fn open_directory_store<P: Into<PathBuf>>(path: P) -> Store {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::storage::directory::NoFilenameEncoding;
     use tempfile::tempdir;
 
     async fn create_and_manipulate_database(store: Store) {
@@ -979,7 +998,7 @@ mod tests {
     #[tokio::test]
     async fn create_and_manipulate_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
 
         create_and_manipulate_database(store).await;
     }
@@ -1502,7 +1521,7 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
 
         cached_layer_name_does_not_change_after_rollup(store).await
     }
@@ -1548,14 +1567,14 @@ mod tests {
     #[tokio::test]
     async fn dir_cached_layer_name_does_not_change_after_rollup_upto() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         cached_layer_name_does_not_change_after_rollup_upto(store).await
     }
 
     #[tokio::test]
     async fn force_update_with_matching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1570,7 +1589,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatching_0_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let (layer, version) = graph.head_version().await.unwrap();
         assert!(layer.is_none());
@@ -1585,7 +1604,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_matching_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1604,7 +1623,7 @@ mod tests {
     #[tokio::test]
     async fn force_update_with_mismatched_version_succeeds() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
 
         let builder = store.create_base_layer().await.unwrap();
@@ -1623,7 +1642,7 @@ mod tests {
     #[tokio::test]
     async fn delete_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let _ = store.create("foo").await.unwrap();
         assert!(store.delete("foo").await.unwrap());
         assert!(store.open("foo").await.unwrap().is_none());
@@ -1632,14 +1651,14 @@ mod tests {
     #[tokio::test]
     async fn delete_nonexistent_database() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         assert!(!store.delete("foo").await.unwrap());
     }
 
     #[tokio::test]
     async fn delete_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         assert!(store.open("foo").await.unwrap().is_some());
         graph.delete().await.unwrap();
@@ -1649,7 +1668,7 @@ mod tests {
     #[tokio::test]
     async fn recreate_graph() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         let graph = store.create("foo").await.unwrap();
         let builder = store.create_base_layer().await.unwrap();
         let layer = builder.commit().await.unwrap();
@@ -1663,7 +1682,7 @@ mod tests {
     #[tokio::test]
     async fn list_databases() {
         let dir = tempdir().unwrap();
-        let store = open_directory_store(dir.path());
+        let store = open_directory_store(dir.path(), NoFilenameEncoding);
         assert!(store.labels().await.unwrap().is_empty());
         let _ = store.create("foo").await.unwrap();
         let one = vec!["foo".to_string()];
diff --git a/src/store/sync.rs b/src/store/sync.rs
index 694012d5..b5ec2000 100644
--- a/src/store/sync.rs
+++ b/src/store/sync.rs
@@ -12,6 +12,7 @@ use std::io;
 use std::path::PathBuf;
 
 use crate::layer::{IdTriple, Layer, LayerCounts, ObjectType, ValueTriple};
+use crate::storage::directory::FilenameEncoding;
 use crate::store::{
     open_directory_store, open_memory_store, NamedGraph, Store, StoreLayer, StoreLayerBuilder,
 };
@@ -568,7 +569,7 @@ impl SyncStore {
         inner.map(SyncStoreLayerBuilder::wrap)
     }
 
-    /// Export the given layers by creating a pack, a Vec<u8> that can later be used with `import_layers` on a different store.
+    /// Export the given layers by creating a pack, a `Vec<u8>` that can later be used with `import_layers` on a different store.
     pub fn export_layers(
         &self,
         layer_ids: Box<dyn Iterator<Item = [u32; 5]> + Send>,
@@ -598,22 +599,41 @@ pub fn open_sync_memory_store() -> SyncStore {
 }
 
 /// Open a store that stores its data in the given directory.
-pub fn open_sync_directory_store<P: Into<PathBuf>>(path: P) -> SyncStore {
-    SyncStore::wrap(open_directory_store(path))
+///
+/// * `filename_encoding` - specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_sync_directory_store<P: Into<PathBuf>>(
+    path: P,
+    filename_encoding: impl FilenameEncoding + 'static,
+) -> SyncStore {
+    SyncStore::wrap(open_directory_store(path, filename_encoding))
 }
 
 /// Open a store that stores its data in the given directory as archive files.
 ///
-/// cache_size specifies in megabytes how large the LRU cache should
+/// * `cache_size` - specifies in megabytes how large the LRU cache should
 /// be. Loaded layers will stick around in the LRU cache to speed up
 /// subsequent loads.
-pub fn open_sync_archive_store<P: Into<PathBuf>>(path: P, cache_size: usize) -> SyncStore {
-    SyncStore::wrap(open_archive_store(path, cache_size))
+/// * `filename_encoding` - specifies how database label is converted into
+/// label file name (pluggable methods must implement FilenameEncoding
+/// trait). Two implementations are provided: NoFilenameEncoding does
+/// no convertion; URLFilenameEncoding convertion is based on URL
+/// encoding algorithm.
+pub fn open_sync_archive_store<P: Into<PathBuf>>(
+    path: P,
+    cache_size: usize,
+    filename_encoding: impl FilenameEncoding + 'static,
+) -> SyncStore {
+    SyncStore::wrap(open_archive_store(path, cache_size, filename_encoding))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::storage::directory::NoFilenameEncoding;
     use tempfile::tempdir;
 
     #[test]
@@ -651,7 +671,7 @@ mod tests {
     #[test]
     fn create_and_manipulate_sync_directory_database() {
         let dir = tempdir().unwrap();
-        let store = open_sync_directory_store(dir.path());
+        let store = open_sync_directory_store(dir.path(), NoFilenameEncoding);
         let database = store.create("foodb").unwrap();
 
         let head = database.head().unwrap();
@@ -716,10 +736,10 @@ mod tests {
     #[test]
     fn export_and_import_pack() {
         let dir1 = tempdir().unwrap();
-        let store1 = open_sync_directory_store(dir1.path());
+        let store1 = open_sync_directory_store(dir1.path(), NoFilenameEncoding);
 
         let dir2 = tempdir().unwrap();
-        let store2 = open_sync_directory_store(dir2.path());
+        let store2 = open_sync_directory_store(dir2.path(), NoFilenameEncoding);
 
         let builder1 = store1.create_base_layer().unwrap();
         builder1