[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6XD4ZJZREMDB6TCNNP74FNS":3,"skill-same:01M6XD4ZJZREMDB6TCNNP74FNS":61},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":35,"linkOnly":36,"markdownContent":37,"markdownBody":38,"frontMatter":39,"refName":40,"commitSha":41,"skillDirectory":42,"forksCount":13,"repositoryHtmlUrl":43,"repositoryHomepageUrl":6,"ownerHtmlUrl":44,"ownerBlogUrl":6,"ownerDescription":45,"updatedAt":46,"install":47,"resources":60},"01M6XD4ZJZREMDB6TCNNP74FNS","erlang-concurrency",null,"Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.","Waaaalnut\u002Fskillsbench","Waaaalnut","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F103995656?v=4","01M6XCS9K1V51EY3JMB7DGMX24","01M6XCS9Q4WPW88W62C55G1H44",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks-no-skills\u002Ffix-erlang-ssh-cve\u002Fenvironment\u002Fskills\u002Ferlang-concurrency\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"erlang concurrency","concurrency","erlang","patterns","when","links","processes","error","systems","message","beam","error handling patterns","use","process","model","vm","error handling","2026-11-10 10:12:30",false,"---\nname: erlang-concurrency\ndescription: Use when erlang's concurrency model including lightweight processes, message passing, process links and monitors, error handling patterns, selective receive, and building massively concurrent systems on the BEAM VM.\n---\n\n# Erlang Concurrency\n\n## Introduction\n\nErlang's concurrency model based on lightweight processes and message passing\nenables building massively scalable systems. Processes are isolated with no shared\nmemory, communicating asynchronously through messages. This model eliminates\nconcurrency bugs common in shared-memory systems.\n\nThe BEAM VM efficiently schedules millions of processes, each with its own heap\nand mailbox. Process creation is fast and cheap, enabling \"process per entity\"\ndesigns. Links and monitors provide failure detection, while selective receive\nenables flexible message handling patterns.\n\nThis skill covers process creation and spawning, message passing patterns,\nprocess links and monitors, selective receive, error propagation, concurrent\ndesign patterns, and building scalable concurrent systems.\n\n## Process Creation and Spawning\n\nCreate lightweight processes for concurrent task execution.\n\n```erlang\n%% Basic process spawning\nsimple_spawn() ->\n    Pid = spawn(fun() ->\n        io:format(\"Hello from process ~p~n\", [self()])\n    end),\n    Pid.\n\n%% Spawn with arguments\nspawn_with_args(Message) ->\n    spawn(fun() ->\n        io:format(\"Message: ~p~n\", [Message])\n    end).\n\n%% Spawn and register\nspawn_registered() ->\n    Pid = spawn(fun() -> loop() end),\n    register(my_process, Pid),\n    Pid.\n\nloop() ->\n    receive\n        stop -> ok;\n        Msg ->\n            io:format(\"Received: ~p~n\", [Msg]),\n            loop()\n    end.\n\n%% Spawn link (linked processes)\nspawn_linked() ->\n    spawn_link(fun() ->\n        timer:sleep(1000),\n        io:format(\"Linked process done~n\")\n    end).\n\n%% Spawn monitor\nspawn_monitored() ->\n    {Pid, Ref} = spawn_monitor(fun() ->\n        timer:sleep(500),\n        exit(normal)\n    end),\n    {Pid, Ref}.\n\n%% Process pools\ncreate_pool(N) ->\n    [spawn(fun() -> worker_loop() end) || _ \u003C- lists:seq(1, N)].\n\nworker_loop() ->\n    receive\n        {work, Data, From} ->\n            Result = process_data(Data),\n            From ! {result, Result},\n            worker_loop();\n        stop ->\n            ok\n    end.\n\nprocess_data(Data) -> Data * 2.\n\n%% Parallel map\npmap(F, List) ->\n    Parent = self(),\n    Pids = [spawn(fun() ->\n        Parent ! {self(), F(X)}\n    end) || X \u003C- List],\n    [receive {Pid, Result} -> Result end || Pid \u003C- Pids].\n\n\n%% Fork-join pattern\nfork_join(Tasks) ->\n    Self = self(),\n    Pids = [spawn(fun() ->\n        Result = Task(),\n        Self ! {self(), Result}\n    end) || Task \u003C- Tasks],\n    [receive {Pid, Result} -> Result end || Pid \u003C- Pids].\n```\n\nLightweight processes enable massive concurrency with minimal overhead.\n\n## Message Passing Patterns\n\nProcesses communicate through asynchronous message passing without shared memory.\n\n```erlang\n%% Send and receive\nsend_message() ->\n    Pid = spawn(fun() ->\n        receive\n            {From, Msg} ->\n                io:format(\"Received: ~p~n\", [Msg]),\n                From ! {reply, \"Acknowledged\"}\n        end\n    end),\n    Pid ! {self(), \"Hello\"},\n    receive\n        {reply, Response} ->\n            io:format(\"Response: ~p~n\", [Response])\n    after 5000 ->\n        io:format(\"Timeout~n\")\n    end.\n\n%% Request-response pattern\nrequest(Pid, Request) ->\n    Ref = make_ref(),\n    Pid ! {self(), Ref, Request},\n    receive\n        {Ref, Response} -> {ok, Response}\n    after 5000 ->\n        {error, timeout}\n    end.\n\nserver_loop() ->\n    receive\n        {From, Ref, {add, A, B}} ->\n            From ! {Ref, A + B},\n            server_loop();\n        {From, Ref, {multiply, A, B}} ->\n            From ! {Ref, A * B},\n            server_loop();\n        stop -> ok\n    end.\n\n%% Publish-subscribe\nstart_pubsub() ->\n    spawn(fun() -> pubsub_loop([]) end).\n\npubsub_loop(Subscribers) ->\n    receive\n        {subscribe, Pid} ->\n            pubsub_loop([Pid | Subscribers]);\n        {unsubscribe, Pid} ->\n            pubsub_loop(lists:delete(Pid, Subscribers));\n        {publish, Message} ->\n            [Pid ! {message, Message} || Pid \u003C- Subscribers],\n            pubsub_loop(Subscribers)\n    end.\n\n%% Pipeline pattern\npipeline(Data, Functions) ->\n    lists:foldl(fun(F, Acc) -> F(Acc) end, Data, Functions).\n\nconcurrent_pipeline(Data, Stages) ->\n    Self = self(),\n    lists:foldl(fun(Stage, AccData) ->\n        Pid = spawn(fun() ->\n            Result = Stage(AccData),\n            Self ! {result, Result}\n        end),\n        receive {result, R} -> R end\n    end, Data, Stages).\n```\n\nMessage passing enables safe concurrent communication without locks.\n\n## Links and Monitors\n\nLinks bidirectionally connect processes while monitors provide one-way observation.\n\n```erlang\n%% Process linking\nlink_example() ->\n    process_flag(trap_exit, true),\n    Pid = spawn_link(fun() ->\n        timer:sleep(1000),\n        exit(normal)\n    end),\n    receive\n        {'EXIT', Pid, Reason} ->\n            io:format(\"Process exited: ~p~n\", [Reason])\n    end.\n\n%% Monitoring\nmonitor_example() ->\n    Pid = spawn(fun() ->\n        timer:sleep(500),\n        exit(normal)\n    end),\n    Ref = monitor(process, Pid),\n    receive\n        {'DOWN', Ref, process, Pid, Reason} ->\n            io:format(\"Process down: ~p~n\", [Reason])\n    end.\n\n%% Supervisor pattern\nsupervisor() ->\n    process_flag(trap_exit, true),\n    Worker = spawn_link(fun() -> worker() end),\n    supervisor_loop(Worker).\n\nsupervisor_loop(Worker) ->\n    receive\n        {'EXIT', Worker, _Reason} ->\n            NewWorker = spawn_link(fun() -> worker() end),\n            supervisor_loop(NewWorker)\n    end.\n\nworker() ->\n    receive\n        crash -> exit(crashed);\n        work -> worker()\n    end.\n```\n\nLinks and monitors enable building fault-tolerant systems with automatic\nfailure detection.\n\n## Best Practices\n\n1. **Create processes liberally** as they are lightweight and cheap to spawn\n\n2. **Use message passing exclusively** for inter-process communication\n   without shared state\n\n3. **Implement proper timeouts** on receives to prevent indefinite blocking\n\n4. **Use monitors for one-way observation** when bidirectional linking unnecessary\n\n5. **Keep process state minimal** to reduce memory usage per process\n\n6. **Use registered names sparingly** as global names limit scalability\n\n7. **Implement proper error handling** with links and monitors for fault tolerance\n\n8. **Use selective receive** to handle specific messages while leaving others queued\n\n9. **Avoid message accumulation** by handling all message patterns in receive clauses\n\n10. **Profile concurrent systems** to identify bottlenecks and optimize hot paths\n\n## Common Pitfalls\n\n1. **Creating too few processes** underutilizes Erlang's concurrency model\n\n2. **Not using timeouts** in receive causes indefinite blocking on failure\n\n3. **Accumulating messages** in mailboxes causes memory leaks and performance degradation\n\n4. **Using shared ETS tables** as mutex replacement defeats isolation benefits\n\n5. **Not handling all message types** causes mailbox overflow with unmatched messages\n\n6. **Forgetting to trap exits** in supervisors prevents proper error handling\n\n7. **Creating circular links** causes cascading failures without proper supervision\n\n8. **Using processes for fine-grained parallelism** adds overhead without benefits\n\n9. **Not monitoring spawned processes** loses track of failures\n\n10. **Overusing registered names** creates single points of failure and contention\n\n## When to Use This Skill\n\nApply processes for concurrent tasks requiring isolation and independent state.\n\nUse message passing for all inter-process communication in distributed systems.\n\nLeverage links and monitors to build fault-tolerant supervision hierarchies.\n\nCreate process pools for concurrent request handling and parallel computation.\n\nUse selective receive for complex message handling protocols.\n\n## Resources\n\n- [Erlang Concurrency Tutorial](\u003Chttps:\u002F\u002Fwww.erlang.org\u002Fdoc\u002Fgetting_started\u002Fconc_prog.html>)\n- [Learn You Some Erlang - Concurrency](\u003Chttps:\u002F\u002Flearnyousomeerlang.com\u002Fthe-hitchhikers-guide-to-concurrency>)\n- [Erlang Process Manual](\u003Chttps:\u002F\u002Fwww.erlang.org\u002Fdoc\u002Freference_manual\u002Fprocesses.html>)\n- [Designing for Scalability with Erlang\u002FOTP](\u003Chttps:\u002F\u002Fwww.oreilly.com\u002Flibrary\u002Fview\u002Fdesigning-for-scalability\u002F9781449361556\u002F>)\n- [Programming Erlang](\u003Chttps:\u002F\u002Fpragprog.com\u002Ftitles\u002Fjaerlang2\u002Fprogramming-erlang-2nd-edition\u002F>)\n","# Erlang Concurrency\n\n## Introduction\n\nErlang's concurrency model based on lightweight processes and message passing\nenables building massively scalable systems. Processes are isolated with no shared\nmemory, communicating asynchronously through messages. This model eliminates\nconcurrency bugs common in shared-memory systems.\n\nThe BEAM VM efficiently schedules millions of processes, each with its own heap\nand mailbox. Process creation is fast and cheap, enabling \"process per entity\"\ndesigns. Links and monitors provide failure detection, while selective receive\nenables flexible message handling patterns.\n\nThis skill covers process creation and spawning, message passing patterns,\nprocess links and monitors, selective receive, error propagation, concurrent\ndesign patterns, and building scalable concurrent systems.\n\n## Process Creation and Spawning\n\nCreate lightweight processes for concurrent task execution.\n\n```erlang\n%% Basic process spawning\nsimple_spawn() ->\n    Pid = spawn(fun() ->\n        io:format(\"Hello from process ~p~n\", [self()])\n    end),\n    Pid.\n\n%% Spawn with arguments\nspawn_with_args(Message) ->\n    spawn(fun() ->\n        io:format(\"Message: ~p~n\", [Message])\n    end).\n\n%% Spawn and register\nspawn_registered() ->\n    Pid = spawn(fun() -> loop() end),\n    register(my_process, Pid),\n    Pid.\n\nloop() ->\n    receive\n        stop -> ok;\n        Msg ->\n            io:format(\"Received: ~p~n\", [Msg]),\n            loop()\n    end.\n\n%% Spawn link (linked processes)\nspawn_linked() ->\n    spawn_link(fun() ->\n        timer:sleep(1000),\n        io:format(\"Linked process done~n\")\n    end).\n\n%% Spawn monitor\nspawn_monitored() ->\n    {Pid, Ref} = spawn_monitor(fun() ->\n        timer:sleep(500),\n        exit(normal)\n    end),\n    {Pid, Ref}.\n\n%% Process pools\ncreate_pool(N) ->\n    [spawn(fun() -> worker_loop() end) || _ \u003C- lists:seq(1, N)].\n\nworker_loop() ->\n    receive\n        {work, Data, From} ->\n            Result = process_data(Data),\n            From ! {result, Result},\n            worker_loop();\n        stop ->\n            ok\n    end.\n\nprocess_data(Data) -> Data * 2.\n\n%% Parallel map\npmap(F, List) ->\n    Parent = self(),\n    Pids = [spawn(fun() ->\n        Parent ! {self(), F(X)}\n    end) || X \u003C- List],\n    [receive {Pid, Result} -> Result end || Pid \u003C- Pids].\n\n\n%% Fork-join pattern\nfork_join(Tasks) ->\n    Self = self(),\n    Pids = [spawn(fun() ->\n        Result = Task(),\n        Self ! {self(), Result}\n    end) || Task \u003C- Tasks],\n    [receive {Pid, Result} -> Result end || Pid \u003C- Pids].\n```\n\nLightweight processes enable massive concurrency with minimal overhead.\n\n## Message Passing Patterns\n\nProcesses communicate through asynchronous message passing without shared memory.\n\n```erlang\n%% Send and receive\nsend_message() ->\n    Pid = spawn(fun() ->\n        receive\n            {From, Msg} ->\n                io:format(\"Received: ~p~n\", [Msg]),\n                From ! {reply, \"Acknowledged\"}\n        end\n    end),\n    Pid ! {self(), \"Hello\"},\n    receive\n        {reply, Response} ->\n            io:format(\"Response: ~p~n\", [Response])\n    after 5000 ->\n        io:format(\"Timeout~n\")\n    end.\n\n%% Request-response pattern\nrequest(Pid, Request) ->\n    Ref = make_ref(),\n    Pid ! {self(), Ref, Request},\n    receive\n        {Ref, Response} -> {ok, Response}\n    after 5000 ->\n        {error, timeout}\n    end.\n\nserver_loop() ->\n    receive\n        {From, Ref, {add, A, B}} ->\n            From ! {Ref, A + B},\n            server_loop();\n        {From, Ref, {multiply, A, B}} ->\n            From ! {Ref, A * B},\n            server_loop();\n        stop -> ok\n    end.\n\n%% Publish-subscribe\nstart_pubsub() ->\n    spawn(fun() -> pubsub_loop([]) end).\n\npubsub_loop(Subscribers) ->\n    receive\n        {subscribe, Pid} ->\n            pubsub_loop([Pid | Subscribers]);\n        {unsubscribe, Pid} ->\n            pubsub_loop(lists:delete(Pid, Subscribers));\n        {publish, Message} ->\n            [Pid ! {message, Message} || Pid \u003C- Subscribers],\n            pubsub_loop(Subscribers)\n    end.\n\n%% Pipeline pattern\npipeline(Data, Functions) ->\n    lists:foldl(fun(F, Acc) -> F(Acc) end, Data, Functions).\n\nconcurrent_pipeline(Data, Stages) ->\n    Self = self(),\n    lists:foldl(fun(Stage, AccData) ->\n        Pid = spawn(fun() ->\n            Result = Stage(AccData),\n            Self ! {result, Result}\n        end),\n        receive {result, R} -> R end\n    end, Data, Stages).\n```\n\nMessage passing enables safe concurrent communication without locks.\n\n## Links and Monitors\n\nLinks bidirectionally connect processes while monitors provide one-way observation.\n\n```erlang\n%% Process linking\nlink_example() ->\n    process_flag(trap_exit, true),\n    Pid = spawn_link(fun() ->\n        timer:sleep(1000),\n        exit(normal)\n    end),\n    receive\n        {'EXIT', Pid, Reason} ->\n            io:format(\"Process exited: ~p~n\", [Reason])\n    end.\n\n%% Monitoring\nmonitor_example() ->\n    Pid = spawn(fun() ->\n        timer:sleep(500),\n        exit(normal)\n    end),\n    Ref = monitor(process, Pid),\n    receive\n        {'DOWN', Ref, process, Pid, Reason} ->\n            io:format(\"Process down: ~p~n\", [Reason])\n    end.\n\n%% Supervisor pattern\nsupervisor() ->\n    process_flag(trap_exit, true),\n    Worker = spawn_link(fun() -> worker() end),\n    supervisor_loop(Worker).\n\nsupervisor_loop(Worker) ->\n    receive\n        {'EXIT', Worker, _Reason} ->\n            NewWorker = spawn_link(fun() -> worker() end),\n            supervisor_loop(NewWorker)\n    end.\n\nworker() ->\n    receive\n        crash -> exit(crashed);\n        work -> worker()\n    end.\n```\n\nLinks and monitors enable building fault-tolerant systems with automatic\nfailure detection.\n\n## Best Practices\n\n1. **Create processes liberally** as they are lightweight and cheap to spawn\n\n2. **Use message passing exclusively** for inter-process communication\n   without shared state\n\n3. **Implement proper timeouts** on receives to prevent indefinite blocking\n\n4. **Use monitors for one-way observation** when bidirectional linking unnecessary\n\n5. **Keep process state minimal** to reduce memory usage per process\n\n6. **Use registered names sparingly** as global names limit scalability\n\n7. **Implement proper error handling** with links and monitors for fault tolerance\n\n8. **Use selective receive** to handle specific messages while leaving others queued\n\n9. **Avoid message accumulation** by handling all message patterns in receive clauses\n\n10. **Profile concurrent systems** to identify bottlenecks and optimize hot paths\n\n## Common Pitfalls\n\n1. **Creating too few processes** underutilizes Erlang's concurrency model\n\n2. **Not using timeouts** in receive causes indefinite blocking on failure\n\n3. **Accumulating messages** in mailboxes causes memory leaks and performance degradation\n\n4. **Using shared ETS tables** as mutex replacement defeats isolation benefits\n\n5. **Not handling all message types** causes mailbox overflow with unmatched messages\n\n6. **Forgetting to trap exits** in supervisors prevents proper error handling\n\n7. **Creating circular links** causes cascading failures without proper supervision\n\n8. **Using processes for fine-grained parallelism** adds overhead without benefits\n\n9. **Not monitoring spawned processes** loses track of failures\n\n10. **Overusing registered names** creates single points of failure and contention\n\n## When to Use This Skill\n\nApply processes for concurrent tasks requiring isolation and independent state.\n\nUse message passing for all inter-process communication in distributed systems.\n\nLeverage links and monitors to build fault-tolerant supervision hierarchies.\n\nCreate process pools for concurrent request handling and parallel computation.\n\nUse selective receive for complex message handling protocols.\n\n## Resources\n\n- [Erlang Concurrency Tutorial](\u003Chttps:\u002F\u002Fwww.erlang.org\u002Fdoc\u002Fgetting_started\u002Fconc_prog.html>)\n- [Learn You Some Erlang - Concurrency](\u003Chttps:\u002F\u002Flearnyousomeerlang.com\u002Fthe-hitchhikers-guide-to-concurrency>)\n- [Erlang Process Manual](\u003Chttps:\u002F\u002Fwww.erlang.org\u002Fdoc\u002Freference_manual\u002Fprocesses.html>)\n- [Designing for Scalability with Erlang\u002FOTP](\u003Chttps:\u002F\u002Fwww.oreilly.com\u002Flibrary\u002Fview\u002Fdesigning-for-scalability\u002F9781449361556\u002F>)\n- [Programming Erlang](\u003Chttps:\u002F\u002Fpragprog.com\u002Ftitles\u002Fjaerlang2\u002Fprogramming-erlang-2nd-edition\u002F>)\n",{"name":5,"description":7},"main","7eeb258ada72b7f58119b0e7a2c00ea89d9beedd","tasks-no-skills\u002Ffix-erlang-ssh-cve\u002Fenvironment\u002Fskills\u002Ferlang-concurrency","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench","https:\u002F\u002Fgithub.com\u002FWaaaalnut","student of Zhejiang University","2026-04-21 23:16:23",{"source":8,"skillName":5,"commands":48,"prompt":58,"zipAvailable":59},[49,52,55],{"tool":50,"command":51},"npx","npx skills add Waaaalnut\u002Fskillsbench --skill erlang-concurrency",{"tool":53,"command":54},"bunx","bunx skills add Waaaalnut\u002Fskillsbench --skill erlang-concurrency",{"tool":56,"command":57},"pnpm","pnpm dlx skills add Waaaalnut\u002Fskillsbench --skill erlang-concurrency","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks-no-skills\u002Ffix-erlang-ssh-cve\u002Fenvironment\u002Fskills\u002Ferlang-concurrency\u002FSKILL.md",true,[],[62,76,90,115,137,156],{"skillNo":63,"name":64,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":72,"publishedAt":35},"01M6XEWMJ6VY3ZC53MPDCPG3GH","data-reconciliation","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fxlsx-recover-data\u002Fenvironment\u002Fskills\u002Fdata-reconciliation\u002FSKILL.md",[67],{"categoryNo":68,"categoryName":69,"taxonomyType":70,"taxonomyTypeDesc":71},"01JBSEEDCAT000000000000033","数据分析师","PROFESSION","适用职业",[73,74,75],"data reconciliation","reconciliation","data",{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":35},"01M6XEW8MNPMF1KRXV6ATGFRQF","speech-to-text","Transcribe video to timestamped text using Whisper tiny model (pre-installed).","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-tutorial-indexer\u002Fenvironment\u002Fskills\u002Fspeech-to-text\u002FSKILL.md",[],[83,84,85,86,87,32,88,89],"speech","text","speech to text","transcribe video","whisper","Video","transcribe",{"skillNo":91,"name":92,"nameZh":6,"description":93,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":94,"categories":95,"keywords":101,"publishedAt":35},"01M6XEW3FQZP0T1RKQQJFXVY9T","video-processor","Process videos by removing segments and concatenating remaining parts. Use when you need to remove detected pauses\u002Fopenings from videos, create highlight reels, or batch process segment removals using ffmpeg filter_complex.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fvideo-processor\u002FSKILL.md",[96],{"categoryNo":97,"categoryName":98,"taxonomyType":99,"taxonomyTypeDesc":100},"01JBSEEDCAT000000000000016","图像与多媒体","SCENARIO","使用场景",[88,102,103,104,105,106,22,107,108,31,109,110,111,112,113,30,114],"processor","video processor","batch","create","reels","parts","segments","videos","you","segment","filter","ffmpeg","remove",{"skillNo":116,"name":117,"nameZh":6,"description":118,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":119,"categories":120,"keywords":122,"publishedAt":35},"01M6XEVXJ5KZ0NTY3XZKRY4AS1","silence-detector","Detect initial silence segments in audio\u002Fvideo using energy-based analysis. Use when you need to find low-energy periods at the start of recordings (title slides, setup time, pre-roll silence).","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fsilence-detector\u002FSKILL.md",[121],{"categoryNo":97,"categoryName":98,"taxonomyType":99,"taxonomyTypeDesc":100},[123,124,125,126,22,110,127,128,129,130,131,108,132,133,88,134,135,136,30],"detector","silence detector","title","slides","time","energy","at","recordings","detect","find","Audio","analysis","start","setup",{"skillNo":138,"name":139,"nameZh":6,"description":140,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":141,"categories":142,"keywords":143,"publishedAt":35},"01M6XEVT3NGRN1FT7JPMAPXS6M","segment-combiner","Combine multiple segment detection results into a unified list. Use when you need to merge segments from different detectors, prepare removal lists for video processing, or consolidate detection outputs.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Fsegment-combiner\u002FSKILL.md",[],[111,144,88,145,146,147,148,149,22,150,151,108,110,152,153,30,154,155],"segment combiner","detection","prepare","merge","video processing","for","outputs","combine","processing","consolidate","results","list",{"skillNo":157,"name":158,"nameZh":6,"description":159,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":9,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":160,"categories":161,"keywords":165,"publishedAt":35},"01M6XEVMPVASGS2KX86QK4FMT7","report-generator","Generate compression reports for video processing. Use when you need to create structured JSON reports with duration statistics, compression ratios, and segment details after video processing.","https:\u002F\u002Fgithub.com\u002FWaaaalnut\u002Fskillsbench\u002Fblob\u002Fmain\u002Ftasks\u002Fvideo-silence-remover\u002Fenvironment\u002Fskills\u002Freport-generator\u002FSKILL.md",[162],{"categoryNo":163,"categoryName":164,"taxonomyType":70,"taxonomyTypeDesc":71},"01JBSEEDCAT000000000000034","行政与办公人员",[166,167,168,111,22,149,110,169,152,170,171,172,30,148,173,88,174,175,105],"generator","report generator","report","with","statistics","structured","reports","json","compression","generate"]