diff --git a/src/sw/redis++/async_redis.h b/src/sw/redis++/async_redis.h
index 425fdc3..8621f49 100644
--- a/src/sw/redis++/async_redis.h
+++ b/src/sw/redis++/async_redis.h
@@ -1613,6 +1613,94 @@ class AsyncRedis {
         return evalsha<Result>(script, keys.begin(), keys.end(), args.begin(), args.end(), std::forward<Callback>(cb));
     }
 
+    template <typename Result, typename Keys, typename Args>
+    Future<Result> fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last) {
+        return _command<Result>(fmt::fcall<Keys, Args>,
+                func, keys_first, keys_last, args_first, args_last);
+    }
+
+    template <typename Result, typename Keys, typename Args, typename Callback>
+    auto fcall(const StringView &func,
+              Keys keys_first,
+              Keys keys_last,
+              Args args_first,
+              Args args_last,
+              Callback &&cb)
+        -> typename std::enable_if<IsInvocable<typename std::decay<Callback>::type, Future<Result> &&>::value, void>::type {
+        _callback_fmt_command<Result>(std::forward<Callback>(cb), fmt::fcall<Keys, Args>,
+                                      func, keys_first, keys_last, args_first, args_last);
+    }
+
+    template <typename Result>
+    Future<Result> fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args) {
+        return fcall<Result>(func,
+                keys.begin(), keys.end(),
+                args.begin(), args.end());
+    }
+
+    template <typename Result, typename Callback>
+    auto fcall(const StringView &func,
+              std::initializer_list<StringView> keys,
+              std::initializer_list<StringView> args,
+              Callback &&cb)
+        -> typename std::enable_if<IsInvocable<typename std::decay<Callback>::type, Future<Result> &&>::value, void>::type {
+        return fcall<Result>(func, keys.begin(), keys.end(), args.begin(), args.end(), std::forward<Callback>(cb));
+    }
+
+    template <typename Result, typename Keys, typename Args>
+    Future<Result> fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last) {
+        return _command<Result>(fmt::fcall_ro<Keys, Args>,
+                func, keys_first, keys_last, args_first, args_last);
+    }
+
+    template <typename Result, typename Keys, typename Args, typename Callback>
+    auto fcall_ro(const StringView &func,
+              Keys keys_first,
+              Keys keys_last,
+              Args args_first,
+              Args args_last,
+              Callback &&cb)
+        -> typename std::enable_if<IsInvocable<typename std::decay<Callback>::type, Future<Result> &&>::value, void>::type {
+        _callback_fmt_command<Result>(std::forward<Callback>(cb), fmt::fcall_ro<Keys, Args>,
+                                      func, keys_first, keys_last, args_first, args_last);
+    }
+
+    template <typename Result>
+    Future<Result> fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args) {
+        return fcall_ro<Result>(func,
+                keys.begin(), keys.end(),
+                args.begin(), args.end());
+    }
+
+    template <typename Result, typename Callback>
+    auto fcall_ro(const StringView &func,
+              std::initializer_list<StringView> keys,
+              std::initializer_list<StringView> args,
+              Callback &&cb)
+        -> typename std::enable_if<IsInvocable<typename std::decay<Callback>::type, Future<Result> &&>::value, void>::type {
+        return fcall_ro<Result>(func, keys.begin(), keys.end(), args.begin(), args.end(), std::forward<Callback>(cb));
+    }
+
+    Future<std::string> function_load(const StringView &code, bool replace = false) {
+        return _command<std::string>(fmt::function_load, code, replace);
+    }
+
+    Future<void> function_delete(const StringView &lib_name) {
+        return _command<void>(fmt::function_delete, lib_name);
+    }
+
     // PUBSUB commands.
 
     Future<long long> publish(const StringView &channel, const StringView &message) {
diff --git a/src/sw/redis++/async_redis_cluster.h b/src/sw/redis++/async_redis_cluster.h
index 1e772ce..8c2a41f 100644
--- a/src/sw/redis++/async_redis_cluster.h
+++ b/src/sw/redis++/async_redis_cluster.h
@@ -1075,6 +1075,54 @@ class AsyncRedisCluster {
                 args.begin(), args.end());
     }
 
+    template <typename Result, typename Keys, typename Args>
+    Future<Result> fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last) {
+        if (keys_first == keys_last) {
+            throw Error("DO NOT support function without key");
+        }
+
+        return _generic_command<Result>(fmt::fcall<Keys, Args>, *keys_first, func,
+                keys_first, keys_last,
+                args_first, args_last);
+    }
+
+    template <typename Result>
+    Future<Result> fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args) {
+        return fcall<Result>(func,
+                keys.begin(), keys.end(),
+                args.begin(), args.end());
+    }
+
+    template <typename Result, typename Keys, typename Args>
+    Future<Result> fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last) {
+        if (keys_first == keys_last) {
+            throw Error("DO NOT support function without key");
+        }
+
+        return _generic_command<Result>(fmt::fcall_ro<Keys, Args>, *keys_first, func,
+                keys_first, keys_last,
+                args_first, args_last);
+    }
+
+    template <typename Result>
+    Future<Result> fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args) {
+        return fcall_ro<Result>(func,
+                keys.begin(), keys.end(),
+                args.begin(), args.end());
+    }
+
     // PUBSUB commands.
 
     Future<long long> publish(const StringView &channel, const StringView &message) {
diff --git a/src/sw/redis++/cmd_formatter.h b/src/sw/redis++/cmd_formatter.h
index abf1517..2467c86 100644
--- a/src/sw/redis++/cmd_formatter.h
+++ b/src/sw/redis++/cmd_formatter.h
@@ -791,6 +791,56 @@ FormattedCommand evalsha(const StringView &script,
     return format_cmd(args);
 }
 
+template <typename Keys, typename Args>
+FormattedCommand fcall(const StringView &func,
+        Keys keys_first,
+        Keys keys_last,
+        Args args_first,
+        Args args_last) {
+    CmdArgs args;
+    auto keys_num = std::distance(keys_first, keys_last);
+
+    args << "FCALL" << func << keys_num
+            << std::make_pair(keys_first, keys_last)
+            << std::make_pair(args_first, args_last);
+
+    return format_cmd(args);
+}
+
+template <typename Keys, typename Args>
+FormattedCommand fcall_ro(const StringView &func,
+        Keys keys_first,
+        Keys keys_last,
+        Args args_first,
+        Args args_last) {
+    CmdArgs args;
+    auto keys_num = std::distance(keys_first, keys_last);
+
+    args << "FCALL_RO" << func << keys_num
+            << std::make_pair(keys_first, keys_last)
+            << std::make_pair(args_first, args_last);
+
+    return format_cmd(args);
+}
+
+inline FormattedCommand function_load(const StringView &code, bool replace) {
+    CmdArgs cmd_args;
+
+    cmd_args << "FUNCTION" << "LOAD";
+
+    if (replace) {
+        cmd_args << "REPLACE";
+    }
+
+    cmd_args << code;
+
+    return format_cmd(cmd_args);
+}
+
+inline FormattedCommand function_delete(const StringView &lib_name) {
+    return format_cmd("FUNCTION DELETE %b", lib_name.data(), lib_name.size());
+}
+
 // PUBSUB commands.
 
 inline FormattedCommand psubscribe(const StringView &pattern) {
diff --git a/src/sw/redis++/command.h b/src/sw/redis++/command.h
index c10a536..5ee80e6 100644
--- a/src/sw/redis++/command.h
+++ b/src/sw/redis++/command.h
@@ -1568,6 +1568,62 @@ inline void script_load(Connection &connection, const StringView &script) {
     connection.send("SCRIPT LOAD %b", script.data(), script.size());
 }
 
+template <typename Keys, typename Args>
+inline void fcall(Connection &connection,
+                       const StringView &func,
+                       Keys keys_first,
+                       Keys keys_last,
+                       Args args_first,
+                       Args args_last) {
+    CmdArgs cmd_args;
+
+    auto keys_num = std::distance(keys_first, keys_last);
+
+    cmd_args << "FCALL" << func << keys_num
+            << std::make_pair(keys_first, keys_last)
+            << std::make_pair(args_first, args_last);
+
+    connection.send(cmd_args);
+}
+
+template <typename Keys, typename Args>
+inline void fcall_ro(Connection &connection,
+                       const StringView &func,
+                       Keys keys_first,
+                       Keys keys_last,
+                       Args args_first,
+                       Args args_last) {
+    CmdArgs cmd_args;
+
+    auto keys_num = std::distance(keys_first, keys_last);
+
+    cmd_args << "FCALL_RO" << func << keys_num
+            << std::make_pair(keys_first, keys_last)
+            << std::make_pair(args_first, args_last);
+
+    connection.send(cmd_args);
+}
+
+inline void function_load(Connection &connection,
+                            const StringView &code,
+                            bool replace) {
+    CmdArgs cmd_args;
+
+    cmd_args << "FUNCTION" << "LOAD";
+
+    if (replace) {
+        cmd_args << "REPLACE";
+    }
+
+    cmd_args << code;
+
+    connection.send(cmd_args);
+}
+
+inline void function_delete(Connection &connection, const StringView &lib_name) {
+    connection.send("FUNCTION DELETE %b", lib_name.data(), lib_name.size());
+}
+
 // PUBSUB commands.
 
 inline void psubscribe(Connection &connection, const StringView &pattern) {
diff --git a/src/sw/redis++/redis.cpp b/src/sw/redis++/redis.cpp
index 3c0ed4f..761103f 100644
--- a/src/sw/redis++/redis.cpp
+++ b/src/sw/redis++/redis.cpp
@@ -855,6 +855,18 @@ std::string Redis::script_load(const StringView &script) {
     return reply::parse<std::string>(*reply);
 }
 
+std::string Redis::function_load(const StringView &code, bool replace) {
+    auto reply = command(cmd::function_load, code, replace);
+
+    return reply::parse<std::string>(*reply);
+}
+
+void Redis::function_delete(const StringView &lib_name) {
+    auto reply = command(cmd::function_delete, lib_name);
+
+    reply::parse<void>(*reply);
+}
+
 // PUBSUB commands.
 
 long long Redis::publish(const StringView &channel, const StringView &message) {
diff --git a/src/sw/redis++/redis.h b/src/sw/redis++/redis.h
index 816445a..15070db 100644
--- a/src/sw/redis++/redis.h
+++ b/src/sw/redis++/redis.h
@@ -3247,6 +3247,62 @@ class Redis {
 
     std::string script_load(const StringView &script);
 
+    template <typename Result, typename Keys, typename Args>
+    Result fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last);
+
+    template <typename Result>
+    Result fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args);
+
+    template <typename Keys, typename Args, typename Output>
+    void fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last,
+                Output output);
+
+    template <typename Output>
+    void fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args,
+                Output output);
+
+    template <typename Result, typename Keys, typename Args>
+    Result fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last);
+
+    template <typename Result>
+    Result fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args);
+
+    template <typename Keys, typename Args, typename Output>
+    void fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last,
+                Output output);
+
+    template <typename Output>
+    void fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args,
+                Output output);
+
+    std::string function_load(const StringView &code, bool replace = false);
+
+    void function_delete(const StringView &lib_name);
+
     // PUBSUB commands.
 
     long long publish(const StringView &channel, const StringView &message);
diff --git a/src/sw/redis++/redis.hpp b/src/sw/redis++/redis.hpp
index 3c97224..5d40f50 100644
--- a/src/sw/redis++/redis.hpp
+++ b/src/sw/redis++/redis.hpp
@@ -1022,6 +1022,88 @@ void Redis::script_exists(Input first, Input last, Output output) {
     reply::to_array(*reply, output);
 }
 
+template <typename Result, typename Keys, typename Args>
+Result Redis::fcall(const StringView &func,
+            Keys keys_first,
+            Keys keys_last,
+            Args args_first,
+            Args args_last) {
+    auto reply = command(cmd::fcall<Keys, Args>, func, keys_first, keys_last, args_first, args_last);
+
+    return reply::parse<Result>(*reply);
+}
+
+template <typename Result>
+Result Redis::fcall(const StringView &func,
+            std::initializer_list<StringView> keys,
+            std::initializer_list<StringView> args) {
+    return fcall<Result>(func, keys.begin(), keys.end(), args.begin(), args.end());
+}
+
+template <typename Keys, typename Args, typename Output>
+void Redis::fcall(const StringView &func,
+            Keys keys_first,
+            Keys keys_last,
+            Args args_first,
+            Args args_last,
+            Output output) {
+    auto reply = command(cmd::fcall<Keys, Args>,
+                            func,
+                            keys_first, keys_last,
+                            args_first, args_last);
+
+    reply::to_array(*reply, output);
+}
+
+template <typename Output>
+void Redis::fcall(const StringView &func,
+            std::initializer_list<StringView> keys,
+            std::initializer_list<StringView> args,
+            Output output) {
+    fcall(func, keys.begin(), keys.end(), args.begin(), args.end(), output);
+}
+
+template <typename Result, typename Keys, typename Args>
+Result Redis::fcall_ro(const StringView &func,
+            Keys keys_first,
+            Keys keys_last,
+            Args args_first,
+            Args args_last) {
+    auto reply = command(cmd::fcall_ro<Keys, Args>, func, keys_first, keys_last, args_first, args_last);
+
+    return reply::parse<Result>(*reply);
+}
+
+template <typename Result>
+Result Redis::fcall_ro(const StringView &func,
+            std::initializer_list<StringView> keys,
+            std::initializer_list<StringView> args) {
+    return fcall_ro<Result>(func, keys.begin(), keys.end(), args.begin(), args.end());
+}
+
+template <typename Keys, typename Args, typename Output>
+void Redis::fcall_ro(const StringView &func,
+            Keys keys_first,
+            Keys keys_last,
+            Args args_first,
+            Args args_last,
+            Output output) {
+    auto reply = command(cmd::fcall_ro<Keys, Args>,
+                            func,
+                            keys_first, keys_last,
+                            args_first, args_last);
+
+    reply::to_array(*reply, output);
+}
+
+template <typename Output>
+void Redis::fcall_ro(const StringView &func,
+            std::initializer_list<StringView> keys,
+            std::initializer_list<StringView> args,
+            Output output) {
+    fcall_ro(func, keys.begin(), keys.end(), args.begin(), args.end(), output);
+}
+
 // Transaction commands.
 
 template <typename Input>
diff --git a/src/sw/redis++/redis_cluster.h b/src/sw/redis++/redis_cluster.h
index 8975808..cef7665 100644
--- a/src/sw/redis++/redis_cluster.h
+++ b/src/sw/redis++/redis_cluster.h
@@ -1065,6 +1065,58 @@ class RedisCluster {
                     std::initializer_list<StringView> args,
                     Output output);
 
+    template <typename Result, typename Keys, typename Args>
+    Result fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last);
+
+    template <typename Result>
+    Result fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args);
+
+    template <typename Keys, typename Args, typename Output>
+    void fcall(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last,
+                Output output);
+
+    template <typename Output>
+    void fcall(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args,
+                Output output);
+
+    template <typename Result, typename Keys, typename Args>
+    Result fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last);
+
+    template <typename Result>
+    Result fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args);
+
+    template <typename Keys, typename Args, typename Output>
+    void fcall_ro(const StringView &func,
+                Keys keys_first,
+                Keys keys_last,
+                Args args_first,
+                Args args_last,
+                Output output);
+
+    template <typename Output>
+    void fcall_ro(const StringView &func,
+                std::initializer_list<StringView> keys,
+                std::initializer_list<StringView> args,
+                Output output);
+
     // PUBSUB commands.
 
     long long publish(const StringView &channel, const StringView &message);
diff --git a/src/sw/redis++/redis_cluster.hpp b/src/sw/redis++/redis_cluster.hpp
index 3068862..c0e8188 100644
--- a/src/sw/redis++/redis_cluster.hpp
+++ b/src/sw/redis++/redis_cluster.hpp
@@ -1002,6 +1002,90 @@ void RedisCluster::evalsha(const StringView &script,
     evalsha(script, keys.begin(), keys.end(), args.begin(), args.end(), output);
 }
 
+template <typename Result, typename Keys, typename Args>
+Result RedisCluster::fcall(const StringView &func,
+                          Keys keys_first,
+                          Keys keys_last,
+                          Args args_first,
+                          Args args_last) {
+    if (keys_first == keys_last) {
+        throw Error("DO NOT support function without key");
+    }
+
+    auto reply = _command(cmd::fcall<Keys, Args>, *keys_first, func, keys_first, keys_last, args_first, args_last);
+
+    return reply::parse<Result>(*reply);
+}
+
+template <typename Result>
+Result RedisCluster::fcall(const StringView &func,
+                            std::initializer_list<StringView> keys,
+                            std::initializer_list<StringView> args) {
+    return fcall<Result>(func, keys.begin(), keys.end(), args.begin(), args.end());
+}
+
+template <typename Keys, typename Args, typename Output>
+void RedisCluster::fcall(const StringView &func,
+                          Keys keys_first,
+                          Keys keys_last,
+                          Args args_first,
+                          Args args_last,
+                          Output output) {
+    if (keys_first == keys_last) {
+        throw Error("DO NOT support function without key");
+    }
+
+    auto reply = _command(cmd::fcall<Keys, Args>,
+                            *keys_first,
+                            func,
+                            keys_first, keys_last,
+                            args_first, args_last);
+
+    reply::to_array(*reply, output);
+}
+
+template <typename Result, typename Keys, typename Args>
+Result RedisCluster::fcall_ro(const StringView &func,
+                          Keys keys_first,
+                          Keys keys_last,
+                          Args args_first,
+                          Args args_last) {
+    if (keys_first == keys_last) {
+        throw Error("DO NOT support function without key");
+    }
+
+    auto reply = _command(cmd::fcall_ro<Keys, Args>, *keys_first, func, keys_first, keys_last, args_first, args_last);
+
+    return reply::parse<Result>(*reply);
+}
+
+template <typename Result>
+Result RedisCluster::fcall_ro(const StringView &func,
+                            std::initializer_list<StringView> keys,
+                            std::initializer_list<StringView> args) {
+    return fcall_ro<Result>(func, keys.begin(), keys.end(), args.begin(), args.end());
+}
+
+template <typename Keys, typename Args, typename Output>
+void RedisCluster::fcall_ro(const StringView &func,
+                          Keys keys_first,
+                          Keys keys_last,
+                          Args args_first,
+                          Args args_last,
+                          Output output) {
+    if (keys_first == keys_last) {
+        throw Error("DO NOT support function without key");
+    }
+
+    auto reply = _command(cmd::fcall_ro<Keys, Args>,
+                            *keys_first,
+                            func,
+                            keys_first, keys_last,
+                            args_first, args_last);
+
+    reply::to_array(*reply, output);
+}
+
 // Stream commands.
 
 template <typename Input>
diff --git a/test/src/sw/redis++/script_cmds_test.h b/test/src/sw/redis++/script_cmds_test.h
index f7adb11..edd69b3 100644
--- a/test/src/sw/redis++/script_cmds_test.h
+++ b/test/src/sw/redis++/script_cmds_test.h
@@ -35,6 +35,8 @@ class ScriptCmdTest {
 private:
     void _run(Redis &instance);
 
+    void _run_function_test(Redis &instance);
+
     RedisInstance &_redis;
 };
 
diff --git a/test/src/sw/redis++/script_cmds_test.hpp b/test/src/sw/redis++/script_cmds_test.hpp
index 86a0e7d..43abb9b 100644
--- a/test/src/sw/redis++/script_cmds_test.hpp
+++ b/test/src/sw/redis++/script_cmds_test.hpp
@@ -32,6 +32,10 @@ void ScriptCmdTest<RedisInstance>::run() {
     cluster_specializing_test(*this,
             &ScriptCmdTest<RedisInstance>::_run,
             _redis);
+
+    cluster_specializing_test(*this,
+            &ScriptCmdTest<RedisInstance>::_run_function_test,
+            _redis);
 }
 
 template <typename RedisInstance>
@@ -117,6 +121,60 @@ void ScriptCmdTest<RedisInstance>::_run(Redis &instance) {
     REDIS_ASSERT(!instance.script_exists("not exist"), "failed to test script exists");
 }
 
+template <typename RedisInstance>
+void ScriptCmdTest<RedisInstance>::_run_function_test(Redis &instance) {
+    auto key1 = test_key("k1");
+    auto key2 = test_key("k2");
+
+    KeyDeleter<Redis> deleter(instance, {key1, key2});
+
+    try {
+        instance.function_delete("swredistestlib");
+    } catch (const Error &) {
+    }
+
+    std::string code = "#!lua name=swredistestlib\n"
+                    "redis.register_function('my_func', function(keys, args) "
+                    "redis.call('set', keys[1], 1);"
+                    "redis.call('set', keys[2], 2);"
+                    "local first = redis.call('get', keys[1]);"
+                    "local second = redis.call('get', keys[2]);"
+                    "return first + second\n"
+                    "end)";
+
+    auto lib_name = instance.function_load(code);
+    REDIS_ASSERT(lib_name == "swredistestlib", "failed to test function_load");
+
+    std::initializer_list<StringView> keys = {key1, key2};
+    std::initializer_list<StringView> empty_list = {};
+
+    auto num = instance.fcall<long long>("my_func", keys, empty_list);
+    REDIS_ASSERT(num == 3, "failed to test fcall");
+
+    num = instance.fcall<long long>("my_func", keys.begin(), keys.end(),
+            empty_list.begin(), empty_list.end());
+    REDIS_ASSERT(num == 3, "failed to test fcall");
+
+    auto is_readonly = false;
+    try {
+        instance.fcall_ro<std::string>("my_func", {}, {});
+    } catch (const Error &) {
+        is_readonly = true;
+    }
+    REDIS_ASSERT(is_readonly, "failed to test fcall_ro");
+
+    code = "#!lua name=swredistestlib\n"
+        "local function readonly_func(keys, args) return 'hello' end\n"
+        "redis.register_function{function_name='my_func', callback=readonly_func, flags={ 'no-writes' }}";
+    lib_name = instance.function_load(code, true);
+    REDIS_ASSERT(lib_name == "swredistestlib", "failed to test function_load");
+
+    auto res = instance.fcall_ro<std::string>("my_func", {}, {});
+    REDIS_ASSERT(res == "hello", "failed to test fcall_ro");
+
+    instance.function_delete("swredistestlib");
+}
+
 }
 
 }