Associations

Icon Associations

Exhaustive list of file and folder associations

File Associations

Files are sorted by priority.

Name Pattern Examples Icon
GitHub Actions (main\|workflow)\.ya?ml$ main.yml
workflow.yaml
GitHub Actions
Github CODE ^CODE_OF_CONDUCT\.(md\|txt)$ CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.txt
Github CODE
Github CONTRIBUTING ^CONTRIBUTING\.(md\|txt)$ CONTRIBUTING.md
CONTRIBUTING.txt
Github CONTRIBUTING
Github COMMIT ^COMMIT_MESSAGE_CONVENTION\.(md\|txt)$ COMMIT_MESSAGE_CONVENTION.md Github COMMIT
Github TEMPLATE .*TEMPLATE\.(md\|txt)$ TEMPLATE.md
TEMPLATE.txt
Github TEMPLATE
README ^(README\|readme)(\.(md\|txt))?$ README.md
README.txt
README
Git Commit Message ^.*COMMIT_EDITMSG$ COMMIT_EDITMSG
ATOM_COMMIT_EDITMSG
Git Commit Message
Git Merge ^MERGE_(HEAD\|MODE\|MSG)$ MERGE_HEAD
MERGE_MODE
MERGE_MSG
Git Merge
Plugin ^plugin.xml$ plugin.xml Plugin
Images .*\.(jpg\|a?png\|jpeg\|gif\|bmp\|bpg\|djvu\|dpx\|jps\|jng\|jxr) *.jpg
*.jpeg
*.png
*.apng
*.gif
*.bmp
*.bpg
*.djvu
*.dpx
*.jps
*.jng
*.jxr
Images
Images (2) .*\.(ico\|dcm\|ecw\|hdp\|hdr\|heic\|heif\|icns\|iff)$ *.ico
*.dcm
*.ecw
*.hdp
*.hdr
*.heif
*.heic
*.icns
*.iff
Images (2)
Images (3) .*\.(pcx\|pict\|pxr\|raw\|sgi\|tga\|tiff\|vsdx\|wbmp?\|px[mbgs])$ *.pcx
*.pict
*.pxr
*.raw
*.sgi
*.tga
*.tiff
*.vsdx
*.wbm
*.wbmp
*.pxm
*.pxb
*.pxs
Images (3)
SVG .*\.svg *.svg SVG
1C .*\.(bsl\|sdbl\|os\|mdo)$ *.bsl
*.mdo
*.sdbl
*.os
1C
3D .*\.(stl\|obj\|3ds\|dxf\|ac\|shader\|geo\|c4d\|tes[ce]\|cginc\|dwg\|jas\|x)$ *.stl
*.obj
*.3ds
*.x
*.dxf
*.ac
*.shader
*.geo
*.c4d
*.tesc
*.tese
*.cginc
*.dxf
*.dwg
*.jas
3D
4D .*\.4d[mb]$ *.4dm
*.4db
4D
A+ .*\.a\+$ *.a+ A+
Access .*\.(adn\|accdb\|accdr\|accdt\|accda\|mdw\|accde\|mam\|maq\|mar\|maf\|laccdb)$ *.adn
*.accdb
*.accdr
*.accdt
*.accda
*.mdw
*.accde
*.mam
*.maq
*.mar
*.maf
*.laccdb
Access
ABAP .*\.(abp\|abap)$ *.abp
*.abap
ABAP
ABC .*\.abc$ *.abc ABC
ABIF .*\.(abif\|ab1\|fsa)$ *.abif
*.ab1
*.fsa
ABIF
Acre ^acre\.config$ acre.config Acre
ActionScript .*\.(as3?\|jsfl)$ *.as
*.as3
*.jsfl
ActionScript
Ada .*\.(ada\|adb\|ads)$ *.ada
*.adb
*.ads
Ada
Adobe Animate .*\.(fla\|xfl)$ *.fla
*.xfl
Adobe Animate
Adobe Elements .*\.ae[pt]$ *.aep
*.aet
Adobe Elements
Adobe Illustrator .*\.(ait?)$ *.ai
*.ait
Adobe Illustrator
Adobe InDesign .*\.(id\|indd\|indl\|indt\|indb\|idml)$ *.id
*.indd
*.indl
*.indt
*.indb
*.idml
Adobe InDesign
Adobe Photoshop .*\.(psb\|psd)$ *.psb
*.psd
Adobe Photoshop
Adobe Premiere .*\.(prel\|prproj\|psq)$ *.prel
*.prproj
*.psq
Adobe Premiere
AdvPL .*\.(prw\|ahu\|aph\|tlpp)$ *.prw
*.ahu
*.aph
*.tlpp
AdvPL
AffectScript .*\.affect$ *.affect AffectScript
Affinity Designer .*\.(afdesign\|afphoto\|afpub)$ *.afdesign
*.afphoto
*.afpub
Affinity Designer
Agda .*\.l?agda$ *.agda
*.lagda
Agda
Akka .*\.akka$ *.akka Akka
AL .*\.al$ *.al AL
Alacritty \.?alacritty\.yml$ alacritty.yml Alacritty
Alex \.alexrc$ .alexrc Alex
Alex Ignore \.alexignore$ .alexignore Alex Ignore
Alloy .*\.als$ *.als Alloy
Alpine Linux ^\.?APKBUILD$ APKBUILD
.APKBUILD
Alpine Linux
AmigaOS .*\.arexx$ *.arexx AmigaOS
AMPL .*\.ampl$ *.ampl AMPL
AmuseWiki .*\.muse *.muse AmuseWiki
Analytica .*\.ana$ *.ana Analytica
Android Manifest ^AndroidManifest\.xml$ AndroidManifest.xml Android Manifest
Android Main ^MainActivity\.java$ MainActivity.java Android Main
Android Smali .*\.(smali\|rsh\|webarchivexml)$ *.smali
*.rsh
*.webarchivexml
Android Smali
AngelScript .*\.(acs\|angelscript)$ *.acs
*.angelscript
AngelScript
Angular-CLI ^\.?angular(-cli)?\.json$ angular.json
angular-cli.json
.angular-cli.json
.angular.json
Angular-CLI
AngularJS ^angular\.(min\.)?js$ angular.js
angular.min.js
AngularJS
Angular .*\.(ng\.html\|ng\.js\|ng-template)$ *.ng.html
*.ng.js
*.ng-template
Angular
Angular Container ngRx .*\.container\.[tj]s$ *.container.js
*.container.ts
*.container.dart
Angular Container ngRx
Angular Component .*\.component\.(dart\|[tj]s)$ *.component.js
*.component.ts
*.component.ts
Angular Component
Angular Controller .*\.controller\.(dart\|[tj]s)$ *.controller.js
*.controller.ts
*.controller.dart
Angular Controller
Angular Directive .*\.directive\.(dart\|[tj]s)$ *.directive.js
*.directive.ts
*.directive.dart
Angular Directive
Angular Guard .*\.guard\.(dart\|[tj]s)$ *.guard.js
*.guard.ts
*.guard.dart
Angular Guard
Angular Interceptor .*\.interceptor\.(dart\|[tj]s)$ *.interceptor.js
*.interceptor.ts
*.interceptor.dart
Angular Interceptor
Angular Routing .*\.routing\.(dart\|[tj]s)$ *.routing.js
*.routing.ts
*.routing.dart
Angular Routing
Angular Module .*\.module\.(dart\|[tj]s)$ *.module.js
*.module.ts
*.module.dart
Angular Module
Angular Service .*\.service\.(dart\|[tj]s)$ *.service.js
*.service.ts
*.service.dart
Angular Service
Angular Page Ionic .*\.page\.(dart\|[tj]s)$ *.page.js
*.page.ts
*.page.dart
Angular Page Ionic
Angular Pipe .*\.pipe\.(dart\|[tj]s)$ *.pipe.js
*.pipe.ts
*.pipe.dart
Angular Pipe
Angular App Routing ^app-routing\.module\.(dart\|[tj]s)$ app-routing.module.js
app-routing.module.ts
app-routing.module.dart
Angular App Routing
Angular Resolver .*\.resolver\.(dart\|[tj]s)$ *.resolver.js
*.resolver.ts
*.resolver.dart
Angular Resolver
Angular Tailwind ^.*\.?ng-tailwind\.(dart\|[tj]s)$ ng-tailwind.js
ng-tailwind.ts
ng-tailwind.dart
Angular Tailwind
Anime Studio .*\.anime.*$ *.anime
*.animestudio
Anime Studio
Ansible ^(ansible\|site\|webservers\|dbservers\|playbook)\.ya?ml$ ansible.yml
site.yml
webservers.yml
dbservers.yml
playbook.yml
Ansible
Ant ^(ant\.xml$\|\.ant) ant.xml
.ant
Ant
ANTLR .*\.g4?$ *.g
*.g4
ANTLR
Antwar.io ^\.?antwar\.conf(ig)?\.[cm]?js$ antwar.conf.js
antwar.config.js
Antwar.io
AnyScript .*\.any *.any AnyScript
Apache Conf ^(apache2?\|httpd).*\.conf$ apache.conf
apache2.conf
httpd.conf
Apache Conf
Apache Conf- ^\.apacheconf$ .apacheconf Apache Conf-
Apache .*\.(vhost\|thrift)$ *.vhost
*.thrift
Apache
Apex .*\.cls *.cls Apex
API Blueprint .*\.apib$ *.apib API Blueprint
API Extractor ^api-extractor(-base)?\.json$ api-extractor.json
api-extractor-base.json
API Extractor
APK .*\.apk$ *.apk APK
APL .*\.apl[acfino]?$ *.apl
*.apla
*.aplc
*.aplf
*.apli
*.apln
*.aplo
APL
Apollo ^apollo\.config\.js$ apollo.config.js Apollo
Appcelerator ^appcelerator\.(js\|ts)$ appcelerator.js
appcelerator.ts
Appcelerator
AppSemble ^(\.appsemblerc\|app-definition)\.ya?ml$ .appsemblerc.yaml
app-definition.yml
AppSemble
Appveyor ^\.?appveyor\.ya?ml$ .appveyor.yml Appveyor
AppleScript .*\.(applescript\|scpt)$ *.applescript
*.scpt
AppleScript
Arc .*\.arc$ *.arc Arc
Arch Linux (\.install\|\.SRCINFO\|PKGBUILD\|\.yaourtrc)$ .install
.SRCINFO
PKGBUILD
.yaourtrc
Arch Linux
Arch Linux Pacman (pacman\.conf\|pamac\.conf)$ pacman.conf
pamac.conf
Arch Linux Pacman
Arduino .*\.ino$ *.ino Arduino
ARM .*\.(arm)$ *.arm ARM
Arttext .*\.(art[34])$ *.art3
*.art4
Arttext
Asciidoc .*\.(ad\|adoc\|asciidoc\|asc)$ *.ad
*.adoc
*.asciidoc
*.asc
Asciidoc
AspectJ .*\.aj$ *.aj AspectJ
Assembly Pure .*\.[ais]$ *.a
*.i
*.s
Assembly Pure
Assembly .*\.(asm\|inc\|ms\|agc\|lst\|aea\|argus\|mitigus)$ *.asm
*.inc
*.ms
*.agc
*.lst
*.aea
*.argus
*.mitigus
Assembly
Assembly Hitachi .*\.h8(SX?\|\d{3})?$ *.h8
*.h8S
*.h8SX
*.h8000
Assembly Hitachi
Assembly Intel .*\.(x(32\|86\|64)\|i386\|80386)$ *.x32
*.x86
*.x64
*.i386
*.80386
Assembly Intel
Assembly Vax .*\.v(ax\|masm)$ *.vax
*.vmasm
Assembly Vax
ASP .*\.(asp\|asa\|aspx\|asax\|ascx\|ashx\|asmx\|axd)$ *.asp
*.asa
*.aspx
*.asax
*.ascx
*.ashx
*.asmx
*.axd
ASP
Astro .*\.astro$ *.astro Astro
Astro Config ^astro\.config\.([cm]?js\|ts)$ astro.config.js
astro.config.ts
Astro Config
Artistic Style ^\.astylerc$ .astylerc Artistic Style
Asymptote .*\.asy$ *.asy Asymptote
Atom .*\.atomproject\.[jc]son$ *.atomproject.json
*.atomproject.cson
Atom
APM ^\.apmrc$ .apmrc APM
Atoum ^.*\.?atoum(\.[^.]+)*\.php *.atoum.php
atoum.config.php
Atoum
ATS .*\.(dats\|hats\|sats)$ *.dats
*.hats
*.sats
ATS
Audacity .*\.aup$ *.aup Audacity
Augeas .*\.aug$ *.aug Augeas
Aurelia ^aurelia(file)?\.js(on)?$ aurelia.js
aurelia.json
aureliafile.json
Aurelia
Authors ^(AUTHORS\|authors)(\.(md\|txt))?$ AUTHORS
AUTHORS.md
AUTHORS.txt
Authors
AutoHotKey .*\.ahkl?$ *.ahk
*.ahkl
AutoHotKey
AutoIt .*\.au3$ *.au3 AutoIt
Avif .*\.avif$ *.avif Avif
AVR .*\.(avr)$ *.avr AVR
Avro .*\.av(cs\|sc\|dl)$ *.avcs
*.avsc
*.avdl
Avro
AWK .*\.[gmn]?awk$ *.awk
*.gawk
*.mawk
*.nawk
AWK
Azure .*\.azcli$ *.azcli Azure
Azure Pipelines ^azure-pipelines\.ya?ml$ azure-pipelines.yml Azure Pipelines
Babel ^\.(babelrc(\.js)?\|languagebabel\|babel)$ .babelrc
.babelrc.js
.languagebabel
.babel
Babel
Babel Config ^babel(\.[\w\-]+)?\.[cm]?js(on)?$ babel.json
babel.config.json
babel.config.js
babel.config.mjs
babel.config.cjs
Babel Config
Baboon ^baboon(\.[\w\-]+)?\.[cm]?js(on)?$ baboon.json
baboon.config.json
baboon.config.js
baboon.config.mjs
baboon.config.cjs
Baboon
Backbone ^backbone([-.]min)?\.js$ backbone.js
backbone.min.js
Backbone
Backup .*\.(bak\|old\|orig)$ *.bak
*.old
*.orig
Backup
Ballerina .*\.balx?$ *.bal
*.balx
Ballerina
Basic .*\.(bas\|vb\|vbs)$ *.bas
*.vb
*.vbs
Basic
Bats .*\.bats$ *.bats Bats
Bazaar ^\.bzrignore$ .bzrignore Bazaar
Bazel .*\.(bzl\|bazel)$ *.bzl
*.bazel
Bazel
Bazel Config (\.bazelrc\|bazel\.rc)$ .bazelrc
bazel.rc
Bazel Config
Bean .*([bB])ean\.java$ javaBean.java
javabean.java
Bean
Behat .*\.feature\.php$ *.feature.php Behat
Behat Config behat(\..*)*\.ya?ml$ behat.yml
behat.config.yml
Behat Config
BEM \.bemjson(\.js)?$ .bemjson
.bemjson.js
BEM
BibTex .*\.(cbx\|bbx\|bbl\|bib\|bst)$ *.cbx
*.bbx
*.bbl
*.bib
*.bst
BibTex
Bicep .*\.bicep$ *.bicep Bicep
Biml .*\.biml$ *.biml Biml
Binder ^binder[-_]requirements\.(in\|txt)$ binder-requirements.in
binder-requirements.txt
binder_requirements.in
Binder
BinTray \.bintray\.json$ .bintray.json BinTray
Bison .*\.(bison\|yy?\|yacc)$ *.bison
*.y
*.yy
*.yacc
Bison
Bitcoin ^bitcoin\.conf$ bitcoin.conf Bitcoin
BitHound \.bithoundrc$ .bithoundrc BitHound
Bitbucket Pipelines ^bitbucket-pipelines\.ya?ml$ bitbucket-pipelines.yml Bitbucket Pipelines
Blade .*\.blade(\.php)?$ *.blade
*.blade.php
Blade
Blender .*\.(blend\|bphys)$ *.blend
*.bphys
Blender
BlitzBasic .*\.(bb\|decls)$ *.bb
*.decls
BlitzBasic
BlueSpec .*\.(bsv\|bspec)$ *.bsv
*.bspec
BlueSpec
Blink .*\.blink$ *.blink Blink
BNF .*\.(bnf\|abnf\|ebnf\|lbnf\|grammar)$ *.bnf
*.ebnf
*.abnf
*.lbnf
*.grammar
BNF
Boo .*\.boo(\.unity)?$ *.boo
*.boo.unity
Boo
Bors ^bors\.toml$ bors.toml Bors
Build Boot .*\.boot$ *.boot Build Boot
Bootstrap ^(custom\.)?bootstrap\..+$ bootstrap.js
bootstrap.ts
bootstrap.css
bootstrap.scss
custom.bootstrap.js
Bootstrap
Bootstrap RC ^\.bootstraprc$ .bootstraprc Bootstrap RC
Bosque .*\.bsq$ *.bsq Bosque
Bower ^(\.bowerrc\|bower\.json)$ .bowerrc
bower.json
Bower
Bowerfile ^[Bb]owerfile$ Bowerfile
bowerfile
Bowerfile
Brainfuck .*\.bf?$ *.bf
*.b
Brainfuck
Brakeman brakeman\.yml$ brakeman.yml Brakeman
Brewfile ^Brewfile$ Brewfile Brewfile
Bro .*\.bro$ *.bro Bro
Broccoli ^Brocfile$ Brocfile Broccoli
Brotli .*\.br$ *.br Brotli
Browserslist \.browserslist(rc)?$ .browserslist
.browserslistrc
Browserslist
Browsersync ^(bs-config\|browser-sync)\.(js\|json)$ bs-config.js
bs-config.json
browser-sync.js
browser-sync.json
Browsersync
Brunch ^brunch-config\.(js\|coffee\|ts)$ brunch-config.js
brunch-config.coffee
brunch-config.ts
Brunch
Buck .*\.buckconfig$ *.buckconfig Buck
BuckleScript .*\.cmj$ *.cmj BuckleScript
BuildKite ^buildkite\.(yml\|yaml)$ buildkite.yml
buildkite.yaml
BuildKite
Bundler ^Gemfile$ Gemfile Bundler
Byond .*\.dm$ *.dm Byond
C .*\.(c\|objc\|idc\|w\|nc\|upc\|cats\|wbm\|xpm)$ *.c
*.objc
*.idc
*.w
*.nc
*.upc
*.cats
*.wbm
*.xpm
C
Cabal .*\.cabal$ *.cabal Cabal
Cabal Project ^cabal\.(config\|project)$ cabal.project
cabal.config
Cabal Project
Caddy ^Caddyfile$ Caddyfile Caddy
Caffe .*\.(caffemodel\|solverstate)$ *.caffemodel
*.solverstate
Caffe
Caffe2 .*\.(caffe2model\|prototxt)$ *.caffe2model
*.prototxt
Caffe2
Cairo .*\.cairo$ *.cairo Cairo
Cakefile ^Cakefile$ Cakefile Cakefile
CakePHP .*\.(cake\|ctp)$ *.cake
*.ctp
CakePHP
Calva .*\.calva(-repl)?$ *.calva
*.calva-repl
Calva
Cargo cargo\.(toml\|lock)$ cargo.toml
cargo.lock
Cargo
Carthage ^Cartfile$ Cartfile Carthage
CASC .*\.casc?$ *.casc
*.cas
CASC
CDDL .*\.cddl$ *.cddl CDDL
Certificate .*\.(crt\|cert\|x509\|pks)$ *.crt
*.cert
*.x509
*.pks
Certificate
Ceylon .*\.ceylon$ *.ceylon Ceylon
CFC .*\.(cfc\|cfm\|cfml\|lucee)$ *.cfc
*.cfm
*.cfml
*.lucee
CFC
Chai ^chai\.([jt]sx?\|es6?\|coffee)$ chai.js
chai.ts
chai.es6
chai.coffee
chai.es6
chai.tsx
Chai
Chameleon .*\.pt$ *.pt Chameleon
Changelog ^(CHANGELOG\|changelog)(\.(md\|txt))? CHANGELOG
CHANGELOG.md
changelog.md
CHANGELOG.txt
Changelog
Chapel .*\.(chpl\|chapel)$ *.chpl
*.chapel
Chapel
ChartJS ^[Cc]hart(\.bundle)?(\.min)?\.[cm]?js$ Chart.js
Chart.bundle
Chart.min.js
ChartJS
Cheetah 3D .*\.jas$ *.jas Cheetah 3D
Chef Knife ^knife.rb$ knife.rb Chef Knife
Chef Berksfile ^(Berks\|Policy)file$ Berksfile
Policyfile
Chef Berksfile
Chocolatey ^chocolatey.*\.ps1$ chocolatey.ps1 Chocolatey
Chrome .*\.(crx\|crdownload)$ *.crx
*.crdownload
Chrome
Chuck .*\.ck$ *.ck Chuck
CircleCI ^\.circleci$ .circleci CircleCI
CircleCI Conf ^circle\.ya?ml$ circle.yml CircleCI Conf
Circuit Board .*\.(brd\|sch\|pcb\|gb[rlsop]\|gt[losp]\|dsn)$ *.brd
*.sch
*.pcb
*.gbr
*.gbo
*.gbl
*.gbs
*.gbp
*.gto
*.gtl
*.gtp
*.gts
*.dsn
Circuit Board
Circuit Board (2) .*\.(gko\|gpt\|gpb\|fab\|pho\|cir\|ckt\|gm?[0-9]+)$ *.gko
*.gpt
*.gpb
*.fab
*.pho
*.cir
*.ckt
*.g0
*.g9
*.gm0
*.gm1
*.g90
Circuit Board (2)
Cirru .*\.cirru$ *.cirru Cirru
CKEditor ^ckeditor5-metadata\.json$ ckeditor5-metadata.json CKEditor
Clarion .*\.clw$ *.clw Clarion
Clean .*\.(icl\|dcl\|abc)$ *.icl
*.dcl
*.abc
Clean
Click .*\.click$ *.click Click
CLIPS .*\.clp$ *.clp CLIPS
Closure Templates .*\.soy$ *.soy Closure Templates
Cloud Foundry .*\.cfignore$ *.cfignore Cloud Foundry
CMake .*\.cmake$ *.cmake CMake
CMakelists ^CMakeLists(\.txt)? CMakeLists
CMakeLists.txt
CMakelists
CNAME ^CNAME$ CNAME CNAME
COBOL .*\.(cob\|cobol\|cbl\|ccp\|cpy)$ *.cob
*.ccp
*.cobol
*.cbl
*.cpy
COBOL
CocoaPods .*\.podspec$ *.podspec CocoaPods
Codacy ^\.codacy\.ya?ml$ .codacy.yml Codacy
CodeClimate ^\.codeclimate\.ya?ml$ .codeclimate.yml CodeClimate
Codecov ^\.?codecov\.ya?ml$ codecov.yml
.codecov.yaml
Codecov
CodeKit ^config\.codekit[23]$ config.codekit2
config.codekit3
CodeKit
Codemeta ^codemeta\.json(ld)?$ codemeta.json
codemeta.jsonld
Codemeta
CodeMirror ^codemirror\.([mc]?js\|ts\|css)$ codemirror.js
codemirror.css
codemirror.ts
codemirror.cjs
CodeMirror
Codeowners ^codeowners$ codeowners Codeowners
CodeShip ^codeship-[\w.-]+\.ya?ml$ codeship-services.yml
codeship-steps.yml
CodeShip
CodeQL .*\.ql$ *.ql CodeQL
CoffeeScript .*\.(coffee\|iced\|litcoffee\|cjsx)$ *.coffee
*.iced
*.litcoffee
*.cjsx
CoffeeScript
CoffeeLint ^coffeelint\.json$ coffeelint.json CoffeeLint
CoffeeLint Ignore \.coffeelintignore$ .coffeelintignore CoffeeLint Ignore
ColdFusion .*\.cf$ *.cf ColdFusion
Collada Khronos .*\.(dae\|collada)$ *.dae
*.collada
Collada Khronos
Commitizen ^\.?cz(rc\|\.(json\|toml\|ya?ml))$ .czrc
.cz.json
cz.toml
.cz.yml
cz.yaml
Commitizen
Commitlint .*\.commitlintrc(\.js(on)?\|\.ya?ml)?$ .commitlintrc
.commitlintrc.js
.commitlintrc.json
.commitlintrc.yml
Commitlint
Commitlint Config ^commitlint\.config\.js$ commitlint.config.js Commitlint Config
Compass ^config\.rb$ config.rb Compass
Compass (2) ^_?(compass\|lemonade)\.scss$ compass.scss
_compass.scss
lemonade.scss
Compass (2)
Component Pascal .*\.cps?$ *.cp
*.cps
Component Pascal
Composer ^composer\.json$ composer.json Composer
Composer Lock ^composer\.lock$ composer.lock Composer Lock
Composer Phar ^composer\.phar$ composer.phar Composer Phar
Computable Document Format .*\.cdf$ *.cdf Computable Document Format
Conan ^(conanfile\.(txt\|py)\|conan\.conf)$ conanfile.py
conanfile.txt
conan.conf
Conan
Conda ^\.condarc$ .condarc Conda
Confluence ^.*\.confluence$ *.confluence Confluence
CoNLL ^.*\.conllu?$ *.conll
*.conllu
CoNLL
Cordova ^cordova([^.]*\.\|-(\d\.)+)[cm]?js$ cordova.js
cordova-config.js
cordova-2.js
Cordova
Coq ^.*\.coq$ *.coq Coq
Corel DRAW ^.*\.(cmx\|ccx\|cdrx?\|cdt)$ *.cmx
*.ccx
*.cdr
*.cdrx
*.cdt
Corel DRAW
Coveralls ^\.coveralls\.ya?ml$ .coveralls.yml Coveralls
CPAN ^(cpanfile\|META\.(yml\|json))$ cpanfile
META.yml
META.json
CPAN
Credits (CREDITS\|credits).* CREDITS
CREDITS.md
CREDITS.txt
credits
Credits
CpcdosC+ ^.*\.cpc$ *.cpc CpcdosC+
Creole ^.*\.creole$ *.creole Creole
Crowdin ^crowdin\.ya?ml$ crowdin.yml Crowdin
Crystal .*\.(cr\|ecr)$ *.cr
*.ecr
Crystal
CSound ^.*\.(orc\|udo\|csc\|sco)$ *.orc
*.udo
*.csc
*.sco
CSound
CSSComb ^\.csscomb\.json$ .csscomb.json CSSComb
CSSLint ^\.csslintrc$ .csslintrc CSSLint
CSS Map .*\.css\.map$ *.css.map CSS Map
CSV .*\.(csv\|tsv)$ *.csv
*.tsv
CSV
Cucumber Features .*\.feature$ *.feature
*.feature
Cucumber Features
Cucumber Config cucumber\.(js\|json\|ts\|ya?ml) cucumber.js
cucumber.json
cucumber.ts
cucumber.yml
Cucumber Config
CUDA .*\.cuh?$ *.cu
*.cuh
CUDA
Cuneiform .*\.cfl$ *.cfl Cuneiform
cURL ^\.curlrc$ .curlrc cURL
Curry .*\.curry$ *.curry Curry
Common Workflow Language .*\.cwl$ *.cwl Common Workflow Language
Cython ^.*\.(pyx\|px[di])$ *.pyx
*.pxd
*.pxi
Cython
Cypress ^cypress.*\.json$ cypress.json
cypress.env.json
Cypress
C++ .*\.(cpp\|c\+\+\|cc\|ii\|mii\|cxx\|ipp\|tcc\|inl)$ *.cpp
*.c++
*.cc
*.ii
*.mii
*.cxx
*.ipp
*.tcc
*.inl
C++
C# .*\.csx?$ *.csx
*.cs
C#
C# Project .*\.csproj$ *.csproj C# Project
C++ Project .*\.vcxproj$ *.vcxproj C++ Project
D3 ^d3(\.v\d+)?[^.]*\.[cm]?js d3.js
d3.mjs
d3.v2.cjs
d3.v10-min.js
D3
Dafny .*\.(dfy\|dafny)$ *.dfy
*.dafny
Dafny
Danmakufu .*\.dnh$ *.dnh Danmakufu
Dal .*\.dal$ *.dal Dal
Dart .*\.dart$ *.dart Dart
Darcs .*\.d(arcs)?patch$ *.darcspatch
*.dpatch
Darcs
Darcs BoringIgnore .*\.d(arcs)?patch$ *.darcspatch
*.dpatch
Darcs BoringIgnore
Dashboard .*\.(cpuprofile\|cloc)$ *.cpuprofile
*.cloc
Dashboard
Dataweave .*\.dwl$ *.dwl Dataweave
DB Project .*\.(dbproj\|sqlproj)$ *.dbproj
*.sqlproj
DB Project
dBase .*\.dbf$ *.dbf dBase
Debian .*\.(deb\|dsc\|control)$ *.deb
*.dsc
*.control
Debian
Delphi .*\.(delphi\|dfm\|dof\|dpr)$ *.delphi
*.dfm
*.dof
*.dpr
Delphi
Deno ^(mod\|import_map)\.(ts\|json)$ mod.ts
import_map.json
Deno
Deno Lock ^lock\.json$ lock.json Deno Lock
Deps ^(DEPS\|Dependencies\|deps)\.(js\|ts\|json\|ya?ml)?$ DEPS
Dependencies
deps.json
deps.ts
deps.js
deps.yaml
Deps
Deps (2) .*\.(deps\|pydeps) *.deps
*.pydeps
Deps (2)
Dependabot ^dependabot\.ya?ml$ dependabot.yml
dependabot.yaml
Dependabot
Detekt ^detekt(-config)?\.ya?ml$ detekt-config.yml
detekt-config.yaml
detekt.yaml
Detekt
DevContainer ^devcontainer\.json$ devcontainer.json DevContainer
DeviceTree .*\.dtsi?$ *.dts
*.dtsi
DeviceTree
Dhall .*\.dhall$ *.dhall Dhall
Dia .*\.dia$ *.dia Dia
Digdag .*\.dig$ *.dig Digdag
DNS Zone .*\.(zone\|arpa)$ *.zone
*.arpa
DNS Zone
Diff .*\.diffs?$ *.diff
*.diffs
Diff
Django Config (manage\|settings\|urls\|[aw]sgi)\.py$ manage.py
settings.py
urls.py
asgi.py
wsgi.py
Django Config
Django .*\.(django\|djt)$ *.djt
*.django
Django
DLL .*\.(dll\|dlc)$ *.dll
*.dlc
DLL
Do .*\.do$ *.do Do
Docbook .*\.(dbk\|docbook)$ *.dbk
*.docbook
Docbook
Doclets \.doclets\.ya?ml$ .doclets.yaml
.doclets.yml
Doclets
Docker .*\.?[dD]ockerfile$ Dockerfile
dockerfile
dev.dockerfile
prodDockerfile
Docker
DockerCompose ^docker-compose(.*)\.(yml\|yaml)$ docker-compose.yml
docker-compose.yaml
docker-compose.dev.yml
DockerCompose
Docker Ignore \.[dD]ockerignore$ .dockerignore
.Dockerignore
Docker Ignore
DocPad .*\.eco$ *.eco DocPad
Docz Config \.?docz(rc)?(\.config)?\.([cm]?js\|json)$ docz.config.js
.doczrc.json
.doczrc.config.mjs
docz.config.cjs
Docz Config
Docz \.docz$ .docz Docz
DogeScript .*\.(doge\|djs)$ *.doge
*.djs
DogeScript
Dojo ^dojo\.[cm]?js$ dojo.js
dojo.mjs
dojo.cjs
Dojo
Dojo RC ^\.dojorc$ .dojorc Dojo RC
DoneJS .*\.component$ *.component DoneJS
DosBOX ^[dD]osbox.*\.conf$ dosbox.conf
dosbox-0.74.conf
Dosbox.conf
DosBOX
DotJS .*\.(def\|dot\|jst)$ *.def
*.dot
*.jst
DotJS
DotNET .*\.net$ *.net DotNET
Doxygen ^[Dd]oxyfile$ Doxyfile
doxyfile
Doxygen
Doxygen (2) .*\.dox$ *.dox Doxygen (2)
Dragula ^dragula(\.min)?\.([cm]?js\|css)$ dragula.js
dragula.css
dragula.min.cjs
dragula.min.css
dragula.mjs
Dragula
DragonFlyBSD .*\.d(ragon)?fly$ *.dfly
*.dragonfly
DragonFlyBSD
draw.io ^\.drawio($\|\.)\|\.d(raw)?io(\.png\|\.svg)?$ .drawio
.dio
.drawio.svg
.drawio.png
draw.io
Drone \.drone\.ya?ml$ .drone.yml
.drone.yaml
Drone
Drools .*\.drl *.drl Drools
Drupal .*\.drupal$ *.drools Drupal
DUB ^dub(\.selections)?\.(json\|sdl)$ dub.json
dub.sdl
dub.selections.json
DUB
Dust.js .*\.dust$ *.dust Dust.js
DVC .*\.dvc$ *.dvc DVC
Dyalog APL .*\.(dyalog\|dyapp\|mipage)$ *.dyalog
*.dyapp
*.mipage
Dyalog APL
Dylan .*\.dylan$ *.dylan Dylan
Dylib .*\.(dylib\|bundle)$ *.dylib
*.bundle
Dylib
E .*\.E$ *.E E
Eagle .*\.eup$ *.eup Eagle
Easybuild .*\.eb$ *.eb Easybuild
eC .*\.e[ch]$ *.ec
*.eh
eC
Ecere .*\.epj$ *.epj Ecere
EclipseLang .*\.ecl(\.txt)?$ *.ecl
*.ecl.txt
EclipseLang
Eclipse .*\.(eclipse\|classpath\|c?project) *.eclipse
*.classpath
*.project
*.cproject
Eclipse
Edge .*\.edge$ *.edge Edge
EditorConfig ^\.(editorconfig\|ecrc)$ .editorconfig
.ecrc
EditorConfig
Egg ^config\.(default\|prod\|test\|local\|unittest)\.js config.default.js
config.prod.js
config.test.js
config.local.js
Egg
Electron \.compilerc(\.json)?$ .compilerc
.compilerc.json
Electron
Electron ASAR .*\.asar$ *.asar Electron ASAR
Electron Forge (^\|\.)forge\.config\.js$ forge.config.js
.forge.config.js
Electron Forge
ElementaryOS ^\.appdata\.xml$ .appdata.xml ElementaryOS
Eiffel .*\.(e\|ecf)$ *.e
*.ecf
Eiffel
EJS .*\.ejs$ *.ejs EJS
ElasticSearch .*\.es$ *.es ElasticSearch
Elixir .*\.(ex\|eex\|exs\|elixir\|leex)$ *.ex
*.eex
*.exs
*.elixir
*.leex
Elixir
Elm .*\.elm$ *.elm Elm
Emacs ^\.emacs.*$ .emacs.conf
.emacsconfig
.emacsrc
Emacs
Emacs Lisp ^.*\.(el\|el[cd]\|gnus\|viper\|ede)$ *.el
*.elc
*.eld
*.gnus
*.viper
*.ede
Emacs Lisp
Emacs Cask ^Cask(file)?$ Cask
Caskfile
Emacs Cask
Email .*\.(eml\|mbox\|mail(map)?)$ *.eml
*.mbox
*.mail
*.mailmap
Email
Ember CLI ^\.ember-cli$ .ember-cli Ember CLI
Ember ^\.ember\.json$ .ember.json Ember
EmberScript .*\.emberscript$ *.emberscript EmberScript
Ensime .*\.ensime$ *.ensime Ensime
EQ .*\.eq$ *.eq EQ
ESDoc ^\.esdoc\.([cm]?js\|json)$ .esdoc.js
.esdoc.json
ESDoc
ESLint .*\.eslintrc(\.[cm]?js(on)?\|\.y(a)?ml)?$ .eslintrc
.eslintrc.js
.eslintrc.mjs
.eslintrc.cjs
.eslintrc.json
.eslintrc.yml
ESLint
ESLint Cache ^\.eslintcache$ .eslintcache ESLint Cache
ESLint Ignore ^\.eslintignore$ .eslintignore ESLint Ignore
ERB .*\.(erb\|ru)$ *.erb
*.ru
ERB
Erlang .*\.(erc\|erlang\|beam\|[ehxy]rl)$ *.erc
*.erl
*.erlang
*.hrl
*.xrl
*.yrl
*.beam
Erlang
Erlang Makefile ^[Ee]make(file)?$ Emake
emakefile
Erlang Makefile
Erlang Makefile (2) ^.*\.emakerfile$ .emakerfile Erlang Makefile (2)
Excel .*\.(xls[mxb]?\|xlm\|xlt[mx]?\|xlam?\|odx\|udf)$ *.xls
*.xlsm
*.xlsx
*.xlsb
*.xlm
*.xla
*.xlam
*.xlt
*.xltm
*.xltx
*.odx
*.udf
Excel
Expo ^app\.config?\.([cm]?js\|ts\|json)$ app.config.js
app.config.json
app.config.ts
Expo
ExtJS ^Extjs(-ext)?\.[cm]?js$ Extjs.js
Extjs-ext.mjs
ExtJS
Fabric ^fabric\.mod\.json$ fabric.mod.json Fabric
Fabfile ^fabfile\.py$ fabfile.py Fabfile
Factor ^\.factor(-rc\|-boot-rc)?$ .factor
.factor-rc
.factor-boot-rc
Factor
Falcon .*\.(fal\|falcon)$ *.fal
*.falcon
Falcon
Fancy .*\.(fy\|fancypack)$ *.fy
*.fancypack
Fancy
Fancy Fake ^Fakefile$ Fakefile Fancy Fake
Fantom .*\.(fan\|fantom)$ *.fan
*.fantom
Fantom
Fasta .*\.(fas\|fasta\|fastq\|faa\|mpfa\|fq\|seq\|fna\|ffn\|frn\|sam)$ *.fas
*.fasta
*.fastq
*.faa
*.mpfa
*.fq
*.seq
*.fna
*.ffn
*.frn
*.sam
Fasta
Fauna .*\.(fql\|faunarc)$ *.fql
*.faunarc
Fauna
Faust .*\.dsp$ *.dsp Faust
Favicon ^favicon\.(ico\|png\|jpg)$ favicon.ico
favicon.png
favicon.jpg
Favicon
FBX .*\.fbx$ *.fbx FBX
Fexl .*\.(fxl\|fexl)$ *.fexl
*.fxl
Fexl
Figma .*\.figma$ *.figma Figma
Final Draft .*\.fdx$ *.fdx Final Draft
Finder ^\.(_+(MACOSX)?\|DS_Store)$ .MACOSX
.__MACOSX
.

.DS_Store
Finder
FirebaseRC .*\.firebaserc$ *.firebaserc FirebaseRC
Firestore ^firestore\.(indexes\.json\|rules)$ firestore.rules
firestore.indexes.json
Firestore
Firebase ^firebase\.json$ firebase.json Firebase
Firebase Bolt .*\.bolt$ *.bolt Firebase Bolt
Firefox .*\.(webapp\|xpi)$ *.webapp
*.xpi
Firefox
Fiddle ^electron-fiddle.*$ electron-fiddle
electron-fiddle.zip
electron-fiddle.rpm
Fiddle
Flash .*\.(swf\|flash\|swc)$ *.swf
*.flash
*.swc
Flash
Flask ^flask\.py$ flask.py Flask
Floobits ^\.floo(rc\|ignore)(\.json)?$ .flooignore
.floorc.json
Floobits
Flow .*\.(flow\|flowconfig)$ *.flow
*.flowconfig
Flow
Flutter ^\.(flutter-plugins\|packages\|metadata)$ .flutter-plugins
.packages
.metadata
Flutter
Flutter Lock ^pubspec\.(lock\|yaml)$ pubspec.lock
pubspec.yaml
Flutter Lock
Flux .*\.(fx\|flux)$ *.flux
*.fx
Flux
Font Bitmap .*\.(pcf\|psf\|psftx\|bdf\|fnt\|fon\|snf\|flf\|tlf\|dwf\|bmf)$ *.pcf
*.psf
*.psftx
*.bdf
*.fnt
*.fon
*.snf
*.flf
*.tlf
*.dwf
*.bmf
Font Bitmap
FontForge .*\.(ff\|pe\|sfd)$ *.ff
*.pe
*.sfd
FontForge
Fossil .*\.?fossil(\.exe)?$ .fossil
fossil.exe
Fossil
For The Record .*\.(ftr\|trm)$ *.ftr
*.trm
For The Record
Fork .*\.issuetracker$ *.issuetracker Fork
Fortran .*\.(f77\|f90\|f95\|for\|fpp)$ *.f77
*.f90
*.f95
*.for
*.fpp
Fortran
FOSSA ^\.fossa\.ya?ml$ .fossa.yml
.fossa.yaml
FOSSA
FOSSAIgnore ^\.fossaignore$ .fossaignore FOSSAIgnore
Fountain ^.*\.fountain$ *.fountain Fountain
Franca IDL ^.*\.(fidl\|fdl\|fdepl)$ *.fidl
*.fdl
*.fdepl
Franca IDL
FreeDesktop .*\.(menu\|desktop\|fd\.o)$ *.menu
*.desktop
*.fd.o
FreeDesktop
FreeDOS .*\.(sys\|dos\|dxelib)$ *.sys
*.dos
*.dxelib
FreeDOS
FreeMarker .*\.(ftl\|freemarker)$ *.ftl
*.freemarker
FreeMarker
FreeMat .*\.mat$ *.mat FreeMat
Frege .*\.fr$ *.fr Frege
FSharp .*\.(fs\|fsi\|fsx\|fsproj)$ *.fs
*.fsi
*.fsx
*.fsproj
FSharp
ftHTML .*\.fthtml$ *.fthtml ftHTML
Fuel UX ^fuelux\..* fuelux.css
fuelux.min.css
fuelux.js
fuelux.min.js
Fuel UX
FuseBox ^fuse\.(js\|mjs)$ fuse.js
fuse.mjs
FuseBox
Futhark .*\.fut$ *.fut Futhark
Galaxy ^galaxy\.ini$ galaxy.ini Galaxy
Galen .*\.g(spec\|test)$ *.gspec
*.gtest
Galen
Gamemaker .*\.gml$ *.gml Gamemaker
GAMS .*\.gms$ *.gms GAMS
GAP .*\.(gap\|gi\|tst)$ *.gap
*.gi
*.tst
GAP
GAUSS .*\.gss$ *.gss GAUSS
Gatsby ^gatsby.*\.(js\|ts) gatsby.js
gatsby.config.js
gatsby.ts
Gatsby
G-Code .*\.(gcode\|nc\|tap\|apt\|mpt\|fnc\|gc\|dnc\|ncf\|ncc\|maz\|hnc\|knc\|g00)$ *.gcode
*.nc
*.tap
*.apt
*.mpt
*.fnc
*.gc
*.dnc
*.ncc
*.ncf
*.maz
*.hnc
*.knc
*.g00
G-Code
GDB .*\.gdb$ *.gdb GDB
Genshi .*\.kid$ *.kid Genshi
Genstat .*\.(gen\|gpi)$ *.gen
*.gpi
Genstat
Gentoo .*\.(ebuild\|eclass)$ *.ebuild
*.eclass
Gentoo
Gemfile ^[Gg]emfile\.lock$ Gemfile.lock
gemfile.lock
Gemfile
GhostScript .*\.ghostscript$ *.ghostscript GhostScript
GIMP .*\.(xcf\|ggr\|gih\|gpl\|vbr)$ *.xcf
*.ggr
*.gih
*.gpl
*.vbr
GIMP
GitLab CI ^\.gitlab-ci\.yml$ .gitlab-ci.yml GitLab CI
GitIgnore ^\.gitignore .gitignore GitIgnore
GitPod ^\.gitpod\.ya?ml$ .gitpod.yml GitPod
Glade .*\.glade$ *.glade Glade
Glide ^glide\.ya?ml$ glide.yaml
glide.yml
Glide
Glitter ^\.glitterrc$ .glitterrc Glitter
glTF .*\.gltf$ *.gltf glTF
Pointwise Glyph .*\.glf$ *.glf Pointwise Glyph
Glyphs .*\.glyphs$ *.glyphs Glyphs
GN .*\.gni?$ *.gni
*.gn
GN
Gnome .*\.(gnome\|gtk)$ *.gnome
*.gtk
Gnome
GNU .*\.?(gnu\|gplv[23]\|[AL]?GPL\|GFDL)$ *.gnu
*.gplv2
*.gplv3
AGPL
LGPL
GFDL
GNU
Gnuplot .*\.(gp\|plo?t\|gnuplot)$ *.gp
*.plot
*.plt
*.gnuplot
Gnuplot
Go Config ^go\.(mod\|sub)$ go.mod
go.sub
Go Config
Godot .*\.(gd\|godot\|tres\|tscn)$ *.gd
*.godot
*.tres
*.tscn
Godot
Golo .*\.(golo)$ *.golo Golo
Gosu .*\.(gs[tx]?\|vark)$ *.gs
*.gst
*.gsx
*.vark
Gosu
GoReleaser ^\.goreleaser\.ya?ml$ .goreleaser.yaml
.goreleaser.yml
GoReleaser
Gradle .*\.gradle$ *.gradle Gradle
Gradle KTS .*\.gradle\.kts$ *.gradle.kts Gradle KTS
Gradlew gradlew$ gradlew Gradlew
Grammatical Framework .*\.gf$ *.gf Grammatical Framework
Graphcool .*\.(graphcool)$ *.graphcool Graphcool
Grapher \.gcx$ .gcx Grapher
GraphQL .*\.(gql\|graphqls?\|gqlconfig)$ *.gql
*.graphql
*.graphqls
*.gqlconfig
GraphQL
GraphQL Config \.graphql(\.?config\|rc).*$ .graphqlconfig
.graphql.config.js
.graphqlrc
.graphqlrc.json
.graphql.config.yaml
GraphQL Config
Graphviz .*\.(dot\|gv\|graphviz)$ *.dot
*.gv
*.graphviz
Graphviz
GraphQL Codegen ^codegen\.(json\|ya?ml)$ codegen.json
codegen.yml
codegen.yaml
GraphQL Codegen
Gravit Designer .*\.gvdesign$ *.gvdesign Gravit Designer
GreenKeeper ^greenkeeper\.json$ greenkeeper.json GreenKeeper
Gridsome ^gridsome\.(config\|client\|server)\.[jt]s$ gridsome.config.js
gridsome.server.js
gridsome.client.ts
Gridsome
Groovy .*\.(gy\|gdsl\|groovy\|grt\|gtpl\|gsp\|gvy)$ *.gy
*.gdsl
*.groovy
*.grt
*.gtpl
*.gsp
*.gvy
Groovy
Grunt [gG]runtfile.* gruntfile
Gruntfile
gruntfile.js
Gruntfile.ts
Grunt
Gulp [gG]ulpfile.* gulpfile
Gulpfile
gulpfile.js
Gulpfile.ts
Gulp
H .*\.(objh\|h\|hp\|hpp\|tcc\|hxx)$ *.objh
*.h
*.hp
*.hpp
*.tcc
*.hxx
H
Hack .*\.(hhconfig\|hh\|hhi\|hack)$ *.hhconfig
*.hh
*.hhi
*.hack
Hack
HAML .*\.haml(c\|.deface)?$ *.haml
*.hamlc
*.haml.deface
HAML
Harbour .*\.(prg\|hb)?$ *.prg
*.hb
Harbour
Hashicorp .*\.(hcl\|workflow)$ *.hcl
*.workflow
Hashicorp
Haskell .*\.(haskell\|hs\|hsc\|c2hs\|lhs\|hsig\|hs-boot)$ *.haskell
*.hs
*.hsc
*.c2hs
*.lhs
*.hsig
*.hs-boot
Haskell
Haskell Config ^haskellconfig\.json$ haskellconfig.json Haskell Config
HaxeDevelop .*\.hxproj$ *.hxproj HaxeDevelop
Haxe .*\.(haxe\|hx\|hxsl\|hxml)$ *.haxe
*.hx
*.hxsl
*.hxml
Haxe
HaxeLib ^haxelib\.json$ haxelib.json HaxeLib
Helm .*\.helm$ *.helm Helm
Helmignore ^\.helmignore$ .helmignore Helmignore
Helm Charts ^(Chart\|values\|helmfile)\.ya?ml$ Chart.yaml
helmfile.yml
values.yaml
Helm Charts
Help .*\.(chm\|hlp)$ *.chm
*.hlp
Help
Heroku ^([Pp]rocfile(\.windows)?\|.buildpacks)$ Procfile
Procfile.windows
.buildpacks
Heroku
Heroku Slugignore ^\.slugignore$ .slugignore Heroku Slugignore
Haskell IDE Config ^hie\.ya?ml hie.yml
hie.yaml
Haskell IDE Config
History history.*$ history
history.txt
historyfile
History
HJSON .*\.hjson$ *.hjson HJSON
HLSL .*\.hlsl$ *.hlsl HLSL
HolyC .*\.hc(\.z)?$ *.hc
*.hc.z
HolyC
HomeAssistant .*\.homeassistant$ *.homeassistant HomeAssistant
Hoplon .*\.(hl\|hoplon)$ *.hl
*.hoplon
Hoplon
Horusec ^horusec-config\.json$ horusec-config.json Horusec
Hosts .*\.?hosts$ hosts
*.hosts
Hosts
Houdini .*\.(vfl\|hip\|pic\|geo\|i3d\|picnc)$ *.vfl
*.hip
*.pic
*.geo
*.i3d
*.picnc
Houdini
HoundCI .*\.hound\.ya?ml$ *.hound.yaml HoundCI
HP .*\.(hpgl)$ *.hpgl HP
HTAccess .*\.(htaccess\|htpasswd)$ *.htaccess
*.htpasswd
HTAccess
HTTP .*\.(http\|rest)$ *.http
*.rest
HTTP
HTMLHint \.htmlhintrc$ .htmlhintrc HTMLHint
Hugo config\.toml$ config.toml Hugo
Hunspell .*\.(aff\|dic)$ *.aff
*.dic
Hunspell
Husky .*\.huskyrc(\.[cm]?js\|\.json\|\.ya?ml)?$ .huskyrc.mjs
.huskyrc.cjs.huskyrc
.huskyrc.js
.huskyrc.json
.huskyrc.yaml
.huskyrc.yml
Husky
HY .*\.hy$ *.hy HY
Hygen .*\.ejs\.t$ *.ejs.t Hygen
Hyper \.hyper\.[cm]?js$ .hyper.cjs
.hyper.mjs
.hyper.js
Hyper
Hypr .*\.hypr(\.live)?$ *.hypr
*.hypr.live
Hypr
i18n .*\.(pot\|po\|mo\|strings)$ *.pot
*.po
*.mo
*.strings
i18n
ICL .*\.icl$ *.icl ICL
IcoMoon ^icomoon(\.[-\w]+)*\.json$ icomoon.json
icomoon.dev.json
IcoMoon
ICU .*\.(icu\|nrm)$ *.icu
*.nrm
ICU
IDEA .*\.(iml\|icls)$ *.iml
*.icls
IDEA
Idris .*\.(idr\|lidr\|idris\|ibc\|ipkg)$ *.idr
*.lidr
*.idris
*.ibc
*.ipkg
Idris
IDL .*\.dlm$ *.dlm IDL
IGOR Pro .*\.ipf$ *.ipf IGOR Pro
Imba .*\.imba2?$ *.imba
*.imba2
Imba
ImgBot .*\.imgbotconfig$ *.imgbotconfig ImgBot
Informix .*\.4gl$ *.4gl Informix
Index ^index\.(js\|coffee\|ts\|es6\|html\|scss)$ index.js
index.ts
index.coffee
index.es6
index.html
index.scss
Index
InitPy ^__init__\.py$ init.py InitPy
Infopath .*\.(xsn\|xsf\|xtp2\|infopathxml)$ *.xsn
*.xsf
*.xtp2
*.infopathxml
Infopath
Inform 7 .*\.(ni\|i7x)$ *.ni
*.i7x
Inform 7
Ink .*\.ink2?$ *.ink
*.ink2
Ink
Inkscape .*\.inx$ *.inx Inkscape
InnoSetup .*\.is[sl]$ *.iss
*.isl
InnoSetup
Istanbul .*\.nycrc(\.json\|\.ya?ml)?$ *.nycrc.json
*.nycrc
*.nycrc.yml
Istanbul
Istanbul Conf nyc\.config\.[cm]?js$ nyc.config.js
nyc.config.cjs
nyc.config.mjs
Istanbul Conf
Io .*\.io$ *.io Io
Iodine .*\.iodine$ *.iodine Iodine
Ioke .*\.ik$ *.ik Ioke
Ionic ^ionic\.(config\|project)(\.json)?$ ionic.config
ionic.project
ionic.config.json
Ionic
Isabelle .*\.thy$ *.thy Isabelle
J .*\.(ijs)$ *.ijs J
Jade/Pug .*\.(jade\|pug)$ *.jade
*.pug
Jade/Pug
Jade/Pug Lint ^\.(jade\|pug)-lintrc(\.js(on)?)?$ .jade-lintrc
.pug-lintrc.json
.jade-lintrc.json
.pug-lintrc.js
Jade/Pug Lint
Jake ^.*\.jake$ *.jake Jake
Jakefile ^([jJ])akefile(\.js)?$ Jakefile
jakefile.js
Jakefile
Janet .*\.janet$ *.janet Janet
Jasmine ^\.?jasmine\.json$\|^jasmine\.([-\w]+\.)?([cm]?js\|ts\|coffee)$ jasmine.json
jasmine.js
jasmine.config.ts
jasmine.dev.coffee
Jasmine
Javascript (old) .*\.(js[bm]\|jspre\|jscript\|jslib\|dust\|htc\|pjs\|ssjs)$ *.jsb
*.jsm
*.jspre
*.jscript
*.jslib
*.dust
*.htc
*.pjs
*.ssjs
Javascript (old)
JBuilder .*\.jbuilder$ *.jbuilder JBuilder
Jekyll Config ^_config\.yml$ _config.yml Jekyll Config
Jekyll .*\.jekyll$ *.jekyll Jekyll
Jenkins ^([jJ])enkinsfile.* jenkinsfile
Jenkinsfile.groovy
Jenkins
Jest ^jest(\.(config\|setup\|teardown\|babel))?\.(js(on\|x)?\|[cm]?js\|tsx?)$ jest.config.js
jest.setup.js
jest.teardown.js
jest.babel.json
jest.jsx
jest.tsx
Jest
Jestrc ^\.jestrc.* .jestrc
.jestrc.js
.jestrc.json
Jestrc
JetBrains theme .*\.theme(\.json)?$ *.theme.json
*.theme
JetBrains theme
Jinja .*\.(jinja2?\|j2\|jnj2?)$ *.jinja
*.jinja2
*.j2
*.jnj
*.jnj2
Jinja
Jison .*\.jison(lex)?$ *.jison
*.jisonlex
Jison
Jolie .*\.(ol\|iol\|jolie)$ *.ol
*.iol
*.jolie
Jolie
Joomla .*\.smarty$ *.smarty Joomla
jQuery ^jquery.*\.([jt]s\|coffee\|es6)$ jquery.js
jquery.min.js
jquery.latest.js
jquery.slim.js
jQuery
JSBeautify \.jsbeautify(rc)?$ .jsbeautifyrc
.jsbeautify
JSBeautify
JSCS \.jscsrc$ .jscsrc JSCS
JSHint \.jshintrc$ .jshintrc JSHint
JSHint Ignore \.jshintignore$ .jshintignore JSHint Ignore
JS Map .*\.[cm]?js\.map$ *.js.map
*.cjs.map
*.mjs.map
JS Map
JS Config \.?jsconfig.*\.(js\|json)$ jsconfig.js
jsconfig.json
.jsconfig.js
.jsconfig.json
JS Config
jscpd \.jscpd(\.json\|\.html\|\.xml)$ .jscpd.json
.jscpd.html
.jscpd.xml
jscpd
JSON5 .*\.json5$ *.json5 JSON5
JSON LD .*\.(json-?ld\|ldjson\|jsonl)$ *.jsonld
*.ldjson
*.jsonl
*.json-ld
JSON LD
Jsonnet .*\.(jsonnet\|libsonnet)$ *.jsonnet
*.libsonnet
Jsonnet
JSP .*\.(jsp\|jsf\|jspx) *.jsp
*.jsf
*.jspx
JSP
JSS .*\.jss$ *.jss JSS
Julia .*\.(julia\|jl)$ *.julia
*.jl
Julia
Jupyter Notebook .*\.ipynb$ *.ipynb Jupyter Notebook
Jupyter Notebook (2) ^Notebook$ Notebook Jupyter Notebook (2)
Junos .*\.(jos\|slax)$ *.jos
*.slax
Junos
Kaitai .*\.ksy$ *.ksy Kaitai
Karma ^karma\.conf(ig)?\.(js\|ts\|coffee)$ karma.conf.js
karma.conf.ts
karma.config.coffee
Karma
KerboScript .*\.ks$ *.ks KerboScript
Keybase ^keybase\.txt$ keybase.txt Keybase
Keynote .*\.(knt\|keynote)$ *.knt
*.keynote
Keynote
Key .*\.(key\|pem\|gpg\|pub\|der\|ssh\|passwd\|kdbx) *.key
*.pem
*.gpg
*.pub
*.der
*.ssh
*.passwd
*.kdbx
Key
Kibo .*\.hypr(\.live)?$ *.hypr
*.hypr.live
Kibo
KiCad .*\.kicad_.*$ *.kicad_pcb
*.kicad_pcb-bak
*.kicad_mod
*.kicad_wks
KiCad
KitchenCI ^\.?kitchen(\.[-\w]*)*\.ya?ml$ kitchen.yml
.kitchen.yml
kitchen.local.yml
kitchen.dev.yaml
KitchenCI
Kite ^\.kiteignore$ .kiteignore Kite
Kivy .*\.kv$ *.kv Kivy
KML .*\.kml$ *.kml KML
KL .*\.kl$ *.kl KL
KNIME ^knime\.ini$ knime.ini KNIME
Knockout ^knockout(.*)\.js$ knockout.js
knockout.min.js
Knockout
Kubernetes ^kubernetes.*\.ya?ml$ kubernetes.yml
kubernetes.dev.yaml
Kubernetes
Kubernetes Deployments ^(deployment\|configmap\|service)\.ya?ml$ kubernetes.yml
kubernetes.dev.yaml
deployment.yaml
service.yml
configmap.yaml
Kubernetes Deployments
Kazel Config ^\.?kazelcfg\.json$ kazelcfg.json
.kazelcfg.json
Kazel Config
Kusto .*\.(csl\|kusto)$ *.csl
*.kusto
Kusto
LabVIEW .*\.lv(proj\|lib)$ *.lvproj
*.lvlib
LabVIEW
Lark .*\.lark$ *.lark Lark
Lasso .*\.(las\|ldml\|lasso([89]\|app)?)$ *.las
*.lasso
*.ldml
*.lasso8
*.lasso9
*.lassoapp
Lasso
Latino .*\.lat$ *.lat Latino
Leaflet ^leaflet(.*)\.([cm]?js\|css)$\|^wicket-leaflet\.[cm]?js$ leaflet.draw-src.js
leaflet.draw.css
leaflet.spin.css
leaflet.src.js
wicket-leaflet.mjs
Leaflet
Lean .*\.(lean\|hlean)$ *.lean
*.hlean
Lean
Lefthook ^lefthook(-local)?\.ya?ml$ lefthook.yml
lefthook-local.yaml
Lefthook
Lektor .*\.(lr\|lektor(project)?)$ *.lr
*.lektor
*.lektorproject
Lektor
Leiningen ^project\.clj$ project.clj Leiningen
Lerna ^lerna\.json$ lerna.json Lerna
Lex .*\.(x\|lex\|flex\|lexer)$ *.x
*.lex
*.flex
*.lexer
Lex
LFE .*\.lfe$ *.lfe LFE
LGTM ^\.?lgtm\.ya?ml$ lgtm.yml
.lgtm.yaml
LGTM
Lib .*\.(lib\|bib\|s)$ *.lib
*.bib
*.s
Lib
LibUV .*\.(l?uv\|libuv\|luvit)$ *.libuv
*.luv
*.uv
*.luvit
LibUV
LICENSE ^(licen[cs]e\|LICEN[CS]E)(\.(txt\|md))?$ license
LICENSE
LICENCE.md
licence.txt
LICENSE
LicenseBat ^\.licrc$ .licrc LicenseBat
Lighthouse ^\.?lighthouserc(\.(json\|js\|ya?ml))?$ .lighthouserc
.lighthouserc.json
.lighthouserc.js
lighthouserc.yaml
Lighthouse
Lightwave .*\.(lwo\|lws)$ *.lwo
*.lws
Lightwave
LilyPond .*\.i?ly$ *.ily
*.ly
LilyPond
Lime .*\.(hxp\|lime)$ *.hxp
*.lime
Lime
Link .*\.(url\|lnk\|alias)$ *.url
*.lnk
*.alias
Link
LINQPad .*\.linq$ *.linq LINQPad
Lint Staged .*\.lintstagedrc\.(json\|yml)$ *.lintstagedrc.json
*.lintstagedrc.yml
Lint Staged
Lint Staged Config ^lint-staged\.config\.js$ lint-staged.config.js Lint Staged Config
Liquid .*\.liquid$ *.liquid Liquid
LISP .*\.(cl\|lisp\|lsp\|nl\|ny\|podsl\|sexp\|sbclrc)$ *.cl
*.lisp
*.lsp
*.nl
*.ny
*.podsl
*.sexp
*.sbclrc
LISP
LiveScript (.*\.(ls\|_ls)\|Slakefile)$ *.ls
*._ls
Slakefile
LiveScript
LLVM .*\.(ll\|bc)$ *.ll
*.bc
LLVM
Log .*\.log(\.[0-9]+)? *.log
*.log.0
*.log.9
Log
Log (2) .*\.(rpt\|bug-report\|fdl\|tests)? *.rpt
*.bug-report
*.fdl
*.tests
Log (2)
Logtalk .*\.(logtalk\|lgt)$ *.logtalk
*.lgt
Logtalk
LOLCode .*\.lol$ *.lol LOLCode
LookML .*\.(lkml\|lookml)$ *.lookml
*.lkml
LookML
LSL .*\.lslp?$ *.lsl
*.lslp
LSL
Lakefile ^Lakefile$ Lakefile Lakefile
Lync .*\.(ocrec\|crec)$ *.ocrec
*.crec
Lync
Macaulay2 .*\.m2$ *.m2 Macaulay2
Magento .*\.mage$ *.mage Magento
Magit .*\.magit$ *.magit Magit
Makefile ^((BSD\|GNU)?([mM])ake\|mk)file$ Makefile
makefile
BSDmakefile
GNUmakefile
mkfile
Makefile
Make .*(mk\|mak\|make\|mmk\|mms\|am\|bb)$ *.mk
*.mak
*.make
*.mms
*.am
*.bb
Make
Mako .*(mako\|mao)$ *.mako
*.mao
Mako
Manpage .*\.(man([1-8])?\|ron\|mdoc\|rnh\|rno\|runoff\|roff)$ *.man
*.man1
*.man8
*.ron
*.mdoc
*.rnh
*.rno
*.roff
*.runoff
Manpage
Manifest manifest(\.(json\|bak\|skip\|txt\|xml))?$ manifest.json
manifest.bak
manifest.skip
manifest.txt
manifest.xml
Manifest
Manifest (2) .*\.manifest$ *.manifest Manifest (2)
Manjaro .*\.(pkg\.tar\.xz)$ *.pkg.tar.xz Manjaro
Mapbox .*\.mss$ *.mss Mapbox
MarkdownLint ^\.(markdownlint(rc)?\|mdlrc)(\.(js\|ya?ml\|jsonc?))?$ .markdownlintrc
.markdownlint.json
.markdownlint.yaml
.markdownlint.jsonc
.mdlrc
MarkdownLint
MarkdownLint Ignore ^\.(markdownlintignore\|mdlignore)$ .markdownlintignore
.mdlignore
MarkdownLint Ignore
MarkoJS .*\.marko(\.js)?$ *.marko
*.marko.js
MarkoJS
Markup .*\.(shtml\|dhtml\|dtd)$ *.shtml
*.dhtml
*.dtd
Markup
Materialize ^materialize(\.min)?\.([cm]?js\|css)$ materialize.js
materialize.css
materialize.min.js
materialize.min.css
Materialize
Mathematica .*\.(nb\|nbp\|ma\|mb\|mt\|cdf\|wl\|wlt)$ *.ma
*.mb
*.mt
*.cdf
*.nb
*.nbp
*.wl
*.wlt
Mathematica
Matlab .*\.(matlab\|mlappinstall\|mlpkginstall\|mltbx\|mdlp\|mn\|sldd\|slxp?)$ *.matlab
*.mltbx
*.mdlp
*.mn
*.sldd
*.slx
*.slxp
Matlab
Matlab (2) .*\.(fig\|mexn?\|mexrs6\|mum\|mx3?\|rwd\|smv\|xvc)$ *.fig
*.mex
*.mexn
*.mexrs6
*.mum
*.mx
*.mx3
*.rwd
*.smv
*.xvc
Matlab (2)
Mathjax ^(MathJax[^.]*\|TeX-MML-AM_CHTML)\.[cm]?js$ MathJax.js
MathJax-config.cjs
TeX-MML-AM_CHTML.js
Mathjax
Maven ^pom\.xml$ pom.xml Maven
Max .*\.(max(pat\|help\|proj\|obj)\|pat\|mxt)$ *.maxpat
*.maxobj
*.maxproj
*.maxhelp
*.pat
*.mxt
Max
Maya .*\.(maya\|mel\|mcf[ip])$ *.maya
*.mel
*.mcfi
*.mcfp
Maya
MDX .*\.mdx$ *.mdx MDX
MediaWiki .*\.(media)?wiki$ *.mediawiki
*.wiki
MediaWiki
Mercurial .*\.hg(sub\|substate\|rc)?$ *.hg
.hgsub
.hgsubstate
.hgrc
Mercurial
Mercurial Ignore ^\.hgignore$ .hgignore Mercurial Ignore
Mercury .*\.moo$ *.moo Mercury
Merlin .*\.merlin$ *.merlin Merlin
Mermaid .*\.(mmd\|mermaid)$ *.mermaid
*.mmd
Mermaid
Meson ^(meson\.build\|meson_options\.txt)$ meson.build
meson_options.txt
Meson
Metal .*\.(metal(lib)?\|air)$ *.metal
*.metallib
*.air
Metal
Metapost .*\.(mp\|mf)$ *.mp
*.mf
Metapost
Meteor .*\.meteor$ *.meteor Meteor
Minecraft .*\.mc(function\|level\|pack\|world\|mod\|meta)$ *.mcfunction
*.mclevel
*.mcpack
*.mcworld
*.mcmod
*.mcmeta
Minecraft
Minizinc .*\.(mzn\|dzn)$ *.mzn
*.dzn
Minizinc
Mint .*\.mint$ *.mint Mint
Mirah .*\.(mir(ah)?\|dr?uby)$ *.mir
*.mirah
*.druby
*.duby
Mirah
Mixin \.mixins?\.json$ .mixin.json
.mixins.json
Mixin
mIRC .*\.(mi?rc)$ *.mirc
*.mrc
mIRC
MJML .*\.mjml(slim)?$ *.mjml
*.mjmlslim
MJML
Mkdocs ^\.?mkdocs\.ya?ml$ mkdocs.yaml
.mkdocs.yml
Mkdocs
mLang .*\.(mlang\|pq)$ *.mlang
*.pq
mLang
Mocha ^(mocha\.opts\|\.mocharc)$ mocha.opts
.mocharc
Mocha
Mocha JSON ^\.mocha\.(js\|json\|yml)$ .mocha.js
.mocha.json
.mocha.yml
Mocha JSON
Modelica .*\.mo$ *.mo Modelica
Modernizr ^\.?modernizr(rc)?(\.[cm]?js)?$\|^modernizr([-.]custom\|-\d\.\d+)(\.\d+)?\.[cm]?js$ modernizr.js
.modernizrrc
modernizr.custom.js
modernizr-dev.cjs
Modernizr
ModernWeb ^web-(dev-server\|test-runner)\.config\.([cm]?js)$ web-dev-server.config.js
web-test-runner.config.cjs
ModernWeb
Modo .*\.(modo\|lxo)$ *.modo
*.lxo
Modo
Modula 2 .*\.(mod\|def)$ *.mod
*.def
Modula 2
Modula 3 .*\.(m[3g]\|i[3g])$ *.m3
*.i3
*.mg
*.ig
Modula 3
Modula 3 Makefile ^m3(makefile\|overrides)$ m3makefile
m3overrides
Modula 3 Makefile
Moho .*\.moho(action\|brush\|export\|proj\|style)?$ *.moho
*.mohoaction
*.mohobrush
*.mohoexport
*.mohoproj
*.mohostyle
Moho
Mojolicious .*\.ep$ *.ep Mojolicious
Moleculer ^moleculer\.config\.([cm]?js\|json\|ts)$ moleculer.config.js
moleculer.config.ts
moleculer.config.json
Moleculer
MomentJS ^moment(-with-locales)?(\.min)?\.[cm]?js$ moment.js
moment.min.js
moment-with-locales.cjs
MomentJS
Monkey .*\.monkey$ *.monkey Monkey
Mongodb .*\.(mongodb\|bson\|mongo)$ *.mongodb
*.bson
*.mongo
Mongodb
Monotone ^\.mtn-ignore$ .mtn-ignore Monotone
Moonscript .*\.moon$ *.moon Moonscript
Mootools ^mootools[^.]*\d+\.\d+(.\d+)?[^.]*\.[cm]?js$ mootools.js
mootools.min.js
mootools-nocompat.cjs
Mootools
More .*\.(more\|msg\|utf8)? *.more
*.msg
*.utf8
More
mRuby .*\.mrb$ *.mrb mRuby
MS-DOS .*\.(com\|dos\|ful\|chk)$ *.com
*.dos
*.ful
*.chk
MS-DOS
MSON .*\.mson$ *.mson MSON
MSSQL .*\.([mnl]df)$ *.mdf
*.ndf
*.ldf
MSSQL
Mupad .*\.mnb?$ *.mn
*.mnb
Mupad
Mustache .*\.(mustache\|handlebars\|hbs\|hamlbars\|stache\|emblem)$ *.mustache
*.handlebars
*.hbs
*.hamlbars
*.stache
*.emblem
Mustache
MXML .*\.mxml$ *.mxml MXML
N64 .*\.n64$ *.n64 N64
NAnt .*\.build$ *.build NAnt
Nano .*\.(nano(rc)?)$ *.nano
*.nanorc
Nano
Nanoc ^nanoc\.ya?ml$ nanoc.yaml
nanoc.yml
Nanoc
NASM .*\.nasm$ *.nasm NASM
NDepend .*\.ndproj$ *.ndproj NDepend
Nearley .*\.ne$ *.ne Nearley
Neko .*\.(neko\|n)$ *.neko
*.n
Neko
Neo4j .*\.cyp(her)?$ *.cyp
*.cypher
Neo4j
Neon .*\.neon$ *.neon Neon
Nessus .*\.nasl$ *.nasl Nessus
Nest.land egg\.(json\|ya?ml) egg.json
egg.yml
egg.yaml
Nest.land
Nest \.?nest-cli\.json .nest-cli.json
nest-cli.json
Nest
Nest Config \.?nestconfig\.json .nestconfig.json
nestconfig.json
Nest Config
Nest Adapter .*\.adapter\.[tj]s$ *.adapter.js
*.adapter.ts
Nest Adapter
Nest Controller .*\.controller\.[tj]s$ *.controller.js
*.controller.ts
Nest Controller
Nest Decorator .*\.decorator\.[tj]s$ *.decorator.js
*.decorator.ts
Nest Decorator
Nest Filter .*\.filter\.[tj]s$ *.filter.js
*.filter.ts
Nest Filter
Nest Gateway .*\.gateway\.[tj]s$ *.gateway.js
*.gateway.ts
Nest Gateway
Nest Guard .*\.guard\.[tj]s$ *.guard.js
*.guard.ts
Nest Guard
Nest Interceptor .*\.interceptor\.[tj]s$ *.interceptor.js
*.interceptor.ts
Nest Interceptor
Nest Middleware .*\.middleware\.[tj]s$ *.middleware.js
*.middleware.ts
Nest Middleware
Nest Module .*\.module\.[tj]s$ *.module.js
*.module.ts
Nest Module
Nest Pipe .*\.pipe\.[tj]s$ *.pipe.js
*.pipe.ts
Nest Pipe
Nest Service .*\.service\.[tj]s$ *.service.js
*.service.ts
Nest Service
Netlify ^netlify\.toml$ netlify.toml Netlify
Netlify headers ^_headers$ _headers Netlify headers
Netlify redirects ^_redirects$ _redirects Netlify redirects
Netlinx .*\.(axi\|axs)$ *.axi
*.axs
Netlinx
Netlogo .*\.nlogo$ *.nlogo Netlogo
NewRelic ^newrelic\.yml$ newrelic.yml NewRelic
NextFlow .*\.nf$ *.nf NextFlow
NextFlow Config ^nextflow\.config\.[cm]?js$ nextflow.config.js NextFlow Config
Next JS ^next\.config\.[cm]?js$ next.config.js
next.config.mjs
next.config.cjs
Next JS
NgRx Effects .*\.effects?\.[tj]s$ effect.ts
effect.js
effects.ts
effects.js
NgRx Effects
NgRx Entities .*\.entity\.[tj]s$ entity.ts
entity.js
NgRx Entities
Nib .*\.nib$ *.nib Nib
Nickle .*\.5c$ *.5c Nickle
Nightwatch ^nightwatch\.conf(ig)?\.[cm]?js$ nightwatch.config.js
nightwatch.conf.mjs
nightwatch.config.cjs
Nightwatch
Nimble .*\.nimble$ *.nimble Nimble
Nimrod .*\.nim(rod)?$ *.nim
*.nimrod
Nimrod
Nit .*\.nit$ *.nit Nit
Ninja .*\.ninja(\.d)?$ *.ninja
*.ninja.d
Ninja
Nix .*\.nix$ *.nix Nix
Nmap .*\.(nmap\|nse)$ *.nmap
*.nse
Nmap
Node ^(server\|app\|main)\.(js\|ts\|es6)$ server.js
server.ts
app.js
app.ts
app.es6
main.js
main.ts
main.es6
Node
Node Version .*\.(node(-version)?\|njs)$ .node-version
*.node
*.njs
Node Version
Nodemon ^\.?nodemon\.json$ nodemon.json
.nodemon.json
Nodemon
Nodemon Ignore ^\.nodemonignore$ .nodemonignore Nodemon Ignore
Nokogiri ^\.nokogirirc$ .nokogirirc Nokogiri
Nomad .*\.nomad$ *.nomad Nomad
Noon .*\.noon$ *.noon Noon
Normalize ^normalize(\.min)?\.(css\|less\|scss\|styl)$ normalize.min.css
normalize.min.less
normalize.scss
normalize.styl
Normalize
Note .*\.(scratch\|note)$ *.scratch
*.note
Note
Now now\.json$ now.json Now
Nowignore ^\.nowignore$ .nowignore Nowignore
NPM ^package\.json$ package.json NPM
NPM lock ^package-lock\.json$ package-lock.json NPM lock
NPMFiles ^\.npmrc$ .npmrc NPMFiles
NPM Ignore ^\.npmignore$ .npmignore NPM Ignore
NSIS .*\.nsis?$ *.nsis
*.nsi
NSIS
NSRI ^\.(nsrirc\|integrity)(\.(json\|(config\.)?[cm]?js\|ya?ml))?$ .nsrirc.json
.nsrirc.config.js
.nsrirc.config.yaml
.integrity.json
.integrity.config.cjs
NSRI
Nuke ^(.*\.nu\|Nukefile)$ *.nu
Nukefile
Nuke
NumPy .*\.(numpyw?\|numsc\|npy\|npz)$ *.numpy
*.numpyw
*.numsc
*.npy
*.npz
NumPy
Nuclide .*\.nuclide$ *.nuclide Nuclide
NuGet .*\.(nupkg\|nuspec\|snupkg\|psmdcp)$ *.nuspec
*.nupkg
*.snupkg
*.psmdcp
NuGet
Nunjucks .*\.(njk\|nunj(ucks)?)$ *.njk
*.nunjucks
*.nunj
Nunjucks
Nuxt .*nuxt\.config\.(js\|ts) nuxt.config.js
nuxt.config.ts
Nuxt
NVM .*\.(nvmrc\|esmrc)$ *.nvmrc
*.esmrc
NVM
NWScript .*\.(nss\|ncs\|ndb)$ *.nss
*.ncs
*.ndb
NWScript
Nx ^nx\.json$ nx.json Nx
NXC .*\.nxc$ *.nxc NXC
Oberon .*\.ob2?$ *.ob
*.ob2
Oberon
Objective-C .*\.mm?$ *.mm
*.m
Objective-C
Objective-J .*\.s?j$ *.j
*.sj
Objective-J
OCaml .*\.(ocaml\|ml\|ml[i4ly]\|cmx\|ocamllex\|ocamlyacc)$ *.ocaml
*.ml
*.mli
*.ml4
*.mly
*.mll
*.cmx
*.ocamllex
*.ocamlyacc
OCaml
Octave .*\.octave.*$ *.octave
*.octaverc
*.octave_hist
Octave
Odin .*\.odin$ *.odin Odin
Ogone .*\.(o3\|ogone)$ *.o3
*.ogone
Ogone
OmniGraffle .*\.g(raffle\|diagramstyle\|stencil\|template)$ *.graffle
*.gdiagramstyle
*.gstencil
*.gtemplate
OmniGraffle
OneNote .*\.(one\|onenote)$ *.one
*.onenote
OneNote
OOC .*\.ooc$ *.ooc OOC
Opa .*\.opa$ *.opa Opa
OpenAPI openapi\.(json\|ya?ml)$ openapi.json
openapi.yml
OpenAPI
OpenBSD ^.*\.(open)?bsd$ *.openbsd
*.bsd
OpenBSD
OpenCL .*\.opencl$ *.opencl OpenCL
OpenEdge ABL .*\.(p\|abl)$ *.abl
*.p
OpenEdge ABL
OpenEXR .*\.exr$ *.exr OpenEXR
OpenGL Shading Language .*\.(glslv?\|gsh\|gshader)$ *.glsl
*.glslv
*.gsh
*.gshader
OpenGL Shading Language
OpenGL Vertex Shader .*\.(vrx\|vert\|vertex\|vsh\|vshader)$ *.vrx
*.vert
*.vertex
*.vsh
*.vshader
OpenGL Vertex Shader
OpenGL Fragment Shader .*\.(frag?\|fp\|fsh\|fshader)$ *.fra
*.frag
*.fp
*.fsh
*.fshader
OpenGL Fragment Shader
OpenHAB .*\.things$ *.things OpenHAB
OpenIndiana .*\.p5i$ *.p5i OpenIndiana
OpenOffice .*\.(f?od[fstpgfb])$ *.odf
*.ods
*.odt
*.odp
*.odg
*.odf
*.odb
*.fodt
*.fods
*.fodp
*.fodg
OpenOffice
OpenOffice (2) .*\.(ot[tspg])$ *.ott
*.ots
*.otp
*.otg
OpenOffice (2)
Open Policy Agent .*\.rego$ *.rego Open Policy Agent
OpenSCAD .*\.j?scad$ *.scad
*.jscad
OpenSCAD
OpenStack .*\.(aki\|ari\|ami\|ova\|ovf)$ *.aki
*.ami
*.ari
*.ova
*.ovf
OpenStack
OpenSolaris .*\.(open)?solaris *.solaris
*.opensolaris
OpenSolaris
OpenVMS .*\.(hlb\|cld)$ *.hlb
*.cld
OpenVMS
OpenVPN .*\.ovpn$ *.ovpn OpenVPN
OpenZFS ^vdev\d+$ vdev1
vdev2001
OpenZFS
Org-Mode .*\.org$ *.org Org-Mode
Oracle PLSQL .*\.(pls(ql)?\|plb\|pk[bhs]\|pck)$ *.pls
*.plsql
*.plb
*.pkb
*.pck
*.pks
*.pkh
Oracle PLSQL
OSX Dmg .*\.dmg$ *.dmg OSX Dmg
Outlook .*\.(pst\|bcmx\|oab\|otm\|oft\|nk2)$ *.pst
*.bcmx
*.oab
*.otm
*.oft
*.nk2
Outlook
Oxygene .*\.oxygene$ *.oxygene Oxygene
Oz .*\.oz$ *.oz Oz
Paket ^paket\.(dependencies\|lock\|references\|local\|template)$ paket.dependencies
paket.lock
paket.references
paket.local
paket.template
Paket
Pan .*\.pan$ *.pan Pan
Papyrus .*\.(psc\|pex)$ *.psc
*.pex
Papyrus
Parrot .*\.(parrot\|pasm\|pir)$ *.parrot
*.pasm
*.pir
Parrot
Pascal .*\.(pas(cal)?\|lp[rsik]\|lfm\|lr[st]\|or\|ppu)$ *.pas
*.pascal
*.lpr
*.lps
*.lpk
*.lpi
*.lfm
*.lrs
*.lrt
*.or
*.ppu
Pascal
Patch .*\.(patch\|meld)$ *.patch
*.meld
Patch
Patreon ^PATR(ONS\|EON)\.md$ PATRONS.md
PATREON.md
Patreon
Pawn .*\.(pawn\|pwn\|pgn\|fen)$ *.pawn
*.pwn
*.pgn
*.fen
Pawn
PCD .*\.pcd$ *.pcd PCD
PDDL .*\.(pddl\|plan\|happenings)$ *.pddl
*.plan
*.happenings
PDDL
PDF .*\.pdf$ *.pdf PDF
PegJS .*\.(pegjs\|pegcoffee\|peggy)$ *.pegjs
*.pegcoffee
*.peggy
PegJS
Perl Config ^perl[56]?-?config\.json$ perlconfig.json
perl5config.json
perl6config.json
perl-config.json
Perl Config
Perforce Helix ^\.p4$ .p4 Perforce Helix
Perforce Helix Ignore ^\.p4ignore$ .p4ignore Perforce Helix Ignore
Phalcon .*\.volt$ *.volt Phalcon
PhotoRec ^\.photorec\.cfg$ .photorec.cfg PhotoRec
PHPUnit .*([tT])est\.php$ my.test.php
myTest.php
PHPUnit
PHP Other .*\.(engine\|phar)$ *.engine
*.phar
PHP Other
PHP CS .*\.php_cs$ *.php_cs PHP CS
PHTML .*\.phtml$ *.phtml PHTML
Phoenix ^phoenix\.(ex\|[cm]?js)$ phoenix.ex
phoenix.cjs
phoenix.mjs
phoenix.js
Phoenix
Phrase ^\.phrase(app)?\.ya?ml$ .phrase.yml
.phrase.yaml
.phraseapp.yml
.phraseapp.yml
Phrase
Pickle .*\.(pkl\|pickle)$ *.pkl
*.pickle
Pickle
PICO-8 .*\.(pico8\|p8)$ *.p8
*.pico8
PICO-8
PicoLISP .*\.l$ *.l PicoLISP
Pike .*\.(pike\|pmod)$ *.pike
*.pmod
Pike
PineScript .*\.pine$ *.pine PineScript
Pipfile ^[Pp]ipfile$ Pipfile
pipfile
Pipfile
Pipfile.lock [Pp]ipfile\.lock$ Pipfile.lock
pipfile.lock
Pipfile.lock
Elyra Pipeline .*\.pipeline *.pipeline Elyra Pipeline
PKGSRC ^mk\.conf mk.conf PKGSRC
PlatformIO ^platformio\.ini$ platformio.ini PlatformIO
Play .*\.play$ *.play Play
PList .*\.plist$ *.plist PList
PM2 ^ecosystem\.conf(ig)?.* ecosystem.conf.js
ecosystem.config.ini
ecosystem.conf.json
ecosystem.conf.yml
PM2
Pnpm ^pnpm-(lock\|workspace\|debug)\.yaml pnpm-lock.yaml
pnpm-workspace.yaml
pnpm-debug.yaml
Pnpm
Pnpmfile ^pnpmfile\.js pnpmfile.js Pnpmfile
Pod .*\.(pod6?\|p6l\|nqp)$ *.pod
*.pod6
*.p6l
*.nqp
Pod
PogoScript .*\.pogo$ *.pogo PogoScript
Polymer Config ^polymer\.json$ polymer.json Polymer Config
Polymer .*\.polymer *.polymer Polymer
Pony .*\.pony$ *.pony Pony
PostgreSQL .*\.pgsql$ *.pgsql PostgreSQL
PostCSS .*\.(pcss\|postcss)$ *.pcss
*.postcss
PostCSS
PostCSS Config ^(\.postcssrc\|postcss\.config\.js(on)?)$ .postcssrc
postcss.config.js
postcss.config.json
PostCSS Config
PostHTML ^(\.posthtmlrc\|posthtml\.config\.(yml\|js\|json))$ .posthtmlrc
posthtml.config.yml
.posthtmlrc.json
posthtml.config.json
PostHTML
PostScript .*\.(ps\|eps[fi]?\|gsf\|a[fm]m\|bez\|GS)$ *.ps
*.eps
*.epsi
*.epsf
*.gsf
*.afm
*.amm
*.bez
*.GS
PostScript
POV-Ray SDL .*\.pov$ *.pov POV-Ray SDL
PowerBuilder .*\.(pb[lt]\|sr[wupaj])$ *.pbl
*.pbt
*.srw
*.sru
*.srp
*.sra
*.srj
PowerBuilder
Powerpoint .*\.(ppt\|pptx\|pps\|ppsx\|pot\|potx\|ppa\|ppam)$ *.ppt
*.pptx
*.pps
*.ppsx
*.pot
*.potx
*.ppa
*.ppam
Powerpoint
PowerShell .*\.(powershell\|ps1\|psd1\|psc1\|psm1\|ps1xml\|pssc\|cmd)$ *.powershell
*.ps1
*.psd1
*.psc1
*.psm1
*.pssc
*.cmd
*.ps1xml
PowerShell
Precommit ^\.pre-commit\b.*\.ya?ml$ .pre-commit.yaml
.pre-commit.yml
.pre-commit-hooks.yaml
Precommit
Prettier ^\.prettierrc(\.js(on)?\|\.y(a)?ml)?$ .prettierrc.js
.prettierrc.json
.prettierrc.yml
Prettier
Prettier Config ^prettier\.config\.js$ prettier.config.js Prettier Config
Prettier Ignore ^\.prettierignore$ .prettierignore Prettier Ignore
Prisma Config prisma\.yml prisma.yml Prisma Config
Prisma .*\.prisma$ *.prisma Prisma
Processing .*\.pde$ *.pde Processing
Project .*\.(mp[pt])$ *.mpp
*.mpt
Project
Prolog .*\.(pro\|prolog\|yap)$ *.pro
*.prolog
*.yap
Prolog
Prometheus .*\.rules$ *.rules Prometheus
Propeller Spin .*\.spin$ *.spin Propeller Spin
Properties .*\.properties$ *.properties Properties
PROS ^project\.pros$ project.pros PROS
Proselint ^\.proselintrc$ .proselintrc Proselint
Protobuf .*\.proto(buf3?)?$ *.proto
*.protobuf
*.protobuf3
Protobuf
Protractor ^protractor(\.conf(ig)?)?\.js(on)?$ protractor.js
protractor.json
protractor.conf.js
protractor.config.json
Protractor
Publisher .*\.(puz\|pub)$ *.puz
*.pub
Publisher
PullApprove ^\.?pullapprove\.ya?ml$ pullapprove.yml
.pullapprove.yaml
PullApprove
Puppet .*\.(puppet\|pp\|epp)$ *.puppet
*.pp
*.epp
Puppet
Pure .*\.pure$ *.pure Pure
PureBasic .*\.pbi?$ *.pb
*.pbi
PureBasic
PureScript .*\.(purescript\|purs)$ *.purescript
*.purs
PureScript
PyPI ^requirements\.(in\|txt)$ requirements.in
requirements.txt
PyPI
Pyret .*\.arr$ *.arr Pyret
Pytest ^pytest\.ini$ pytest.ini Pytest
PyTyped .*(\.py)?\.typed$ *.py.typed
*.typed
PyTyped
Python Config ^(python-?config\.json\|pyproject\.toml)$ python-config.json
pythonconfig.json
pyproject.toml
Python Config
Python Config (2) ^(poetry\.lock\|MANIFEST\.in\|\.python-version\|\.coveragerc)$ poetry.lock
.coveragerc
MANIFEST.in
.python-version
Python Config (2)
Python Version ^\.python-?version$ .python-version
.pythonversion
Python Version
PyUp ^\.pyup(\.ya?ml)?$ .pyup.yml
.pyup.yaml
PyUp
Q# .*\.qs$ *.qs Q#
Q/Kdb .*\.[kq]$ *.q
*.k
Q/Kdb
Qiskit .*\.qasm$ *.qasm Qiskit
QlikView .*\.(qvw\|qvd)$ *.qvw
*.qvd
QlikView
Qt .*\.(qml\|qbs)(project\|dir)?$ *.qml
*.qmlproject
*.qbs
*.qmldir
Qt
Quasar ^quasar\.conf\.[cm]?js$ quasar.conf.js
quasar.conf.cjs
Quasar
R .*\.(r\|rd\|rsx)$ *.r
*.rd
*.rsx
R
R Markdown .*\.(rmd\|rmarkdown)$ *.rmd
*.rmarkdown
R Markdown
Racket .*\.(rkt[dl]?\|scrbl)$ *.rkt
*.rktd
*.rktl
*.scrbl
Racket
Raml .*\.raml$ *.raml Raml
Rails ^rails$ rails Rails
Rake .*\.rake$ *.rake Rake
Rakefile ^Rakefile$ Rakefile Rakefile
Razor .*\.(cshtml\|vbhtml)$ *.cshtml
*.vbhtml
Razor
Raphael ^raphael(\.min\|\.no-deps)*\.[cm]?js$ raphael.min.js
raphael.js
raphael.no-deps.mjs
Raphael
Rascal .*\.(rsc\|rascal)$ *.rsc
*.rascal
Rascal
Razzle ^razzle\.config.* razzle.config.js
razzle.config.yaml
Razzle
RData .*\.(RData\|rds\|rdx)$ *.RData
*.rds
*.rdx
RData
RDoc .*\.rdoc$ *.rdoc RDoc
ReadtheDocs ^\.readthedocs\.ya?ml$ .readthedocs.yml
.readthedocs.yaml
ReadtheDocs
RestQL .*\.(rql\|restql)$ *.rql
*.restql
RestQL
RestQL Config ^restql\.ya?ml$ restql.yml
restql.yaml
RestQL Config
React CLI .*\.react-cli$ *.react-cli React CLI
React ^react(-[^.]*)?\.[cm]?js$ react.js
react-min.js
react.mjs
React
ReactOS ^reactos.*$ reactos.ios
reactos.deb
ReactOS
ReasonML .*\.rei? *.re
*.rei
ReasonML
Reason Studios .*\.(reason\|rns\|rsn\|rx2\|sxt) *.reason
*.rns
*.rsn
*.rx2
*.sxt
Reason Studios
Rebol .*\.(reb(ol)?\|r[23])$ *.rebol
*.eb
*.r2
*.r3
Rebol
Red Hat .*\.(rpm(macros)?)$ *.rpm
*.rpmmacros
Red Hat
Red .*\.red *.red Red
RedisDB .*\.rdb *.rdb RedisDB
Redis ^redis-config\.ya?ml redis-config.yml
redis-config.yaml
Redis
Redux Action .*([aA])ctions?\.(js\|ts)$ action.js
actions.ts
myAction.js
myActions.js
my-actions.js
Redux Action
Redux Epic .*([eE])pics?\.(js\|ts)$ epic.js
epics.ts
myEpic.js
myEpics.js
my-epics.js
Redux Epic
Redux Saga .*([sS])agas?\.(js\|ts)$ saga.js
sagas.ts
mySaga.js
mySagas.js
my-sagas.js
Redux Saga
Redux Selector .*([sS])electors?\.(js\|ts)$ selector.js
selectors.ts
mySelector.js
mySelectors.js
my-selectors.js
Redux Selector
Redux Reducer .*([rR])educers?\.(js\|ts)$ reducer.js
reducer.ts
myReducer.js
myReducers.js
my-reducers.js
Redux Reducer
Redux Store .*([sS])tores?\.(js\|ts)$ store.js
store.ts
myStore.js
myStores.js
my-stores.js
Redux Store
Reek .*\.reek$ *.reek Reek
Regexp .*\.(regexp?)$ *.regex
*.regexp
Regexp
Rehype ^\.rehype(rc\|ignore)$ .rehyperc
.rehypeignore
Rehype
Remark ^\.remark(rc\|ignore)$ .remarkrc
.remarkignore
Remark
Renovate (?!^renovate$)(\.\|^)renovate(rc)?(\.json)?$ .renovaterc
renovate.json
Renovate
RequireJS ^require([-.]min\|dev)?\.[cm]?js$ require.js
require.min.cjs
require-dev.mjs
RequireJS
ReScript .*\.resi *.resi ReScript
Restructured .*\.rst$ *.rst Restructured
Retext ^\.retext(rc\|ignore)$ .retextrc
.retextignore
Retext
Rexx .*\.(rexx?\|pprx)$ *.rex
*.rexx
*.pprx
Rexx
Rhino3D .*\.(3dm\|rvb)$ *.3dm
*.rvb
Rhino3D
Riemann ^riemann\.config$ riemann.config Riemann
Ring .*\.ring$ *.ring Ring
Riot .*\.(riot\|tag)$ *.riot
*.tag
Riot
Robot .*\.robot$ *.robot Robot
Rollup ^rollup.* rollup.js
rollup.conf.js
rollup.ts
Rollup
Routes (routing\|routes)\.(js\|jsx\|ts\|tsx)$ routing.js
routes.js
routes.jsx
routing.ts
routes.tsx
Routes
RProj .*\.rproj$ *.rproj RProj
RSpec .*_spec\.rb$ controller_spec.rb
model_spec.rb
RSpec
RSpec Config .*\.rspec$ *.rspec RSpec Config
RStudio .*\.rproj$ *.rproj RStudio
RSS .*\.rss$ *.rss RSS
rsync ^rsyncd\.conf$ rsyncd.conf rsync
Rubocop .*\.rubocop.*\.yml$ *.rubocop.yml Rubocop
RubyGems .*\.gem(spec)?$ *.gem
*.gemspec
RubyGems
Ruby RC Files ^\.?(irbrc\|gemrc\|pryrc)$ .irbrc
.gemrc
.pryrc
Ruby RC Files
Ruby Gemset ^\.ruby-gemset$ .ruby-gemset Ruby Gemset
Ruby Version ^\.ruby-version$ .ruby-version Ruby Version
Rust .*\.(rs\|rust\|rlib)$ *.rs
*.rust
*.rlib
Rust
Rust Toolchain .*\.rust-toolchain$ *.rust-toolchain Rust Toolchain
RVM ^\.rvmrc$ .rvmrc RVM
RxJS rxjs\.[jt]s$ rxjs.js
rxjs.ts
RxJS
SAC .*\.sac$ *.sac SAC
Sage .*\.sage(ws)?$ *.sage
*.sagews
Sage
SailsJS ^\.sailsrc$ .sailsrc SailsJS
SaltStack .*\.sls$ *.sls SaltStack
San .*\.san$ *.san San
Sandbox Profile Language .*\.sb$ *.sb Sandbox Profile Language
SAS .*\.sas$ *.sas SAS
Sapper sapper\.js$ sapper.js Sapper
SBT .*\.sbt$ *.sbt SBT
Scala .*\.(sc\|scala\|kojo)$ *.scala
*.sc
*.kojo
Scala
Scheme .*\.(scheme\|scm\|sld\|sps\|xtm)$ *.scheme
*.scm
*.sld
*.sps
*.xtm
Scheme
Scilla .*\.scilla$ *.scilla Scilla
SciLab .*\.(sci\|sce\|tst)$ *.sci
*.sce
*.tst
SciLab
Scratch .*\.sb[23]$ *.sb2
*.sb3
Scratch
Scrutinizer ^\.scrutinizer\.ya?ml$ .scrutinizer.yml
.scrutinizer.yaml
Scrutinizer
SDLang .*\.sdl$ *.sdl SDLang
Secrets .*\.(secrets?\|safe)$ *.secret
*.secrets
*.safe
Secrets
Self .*\.self$ *.self Self
Sencha ^sencha(\.min)?\.[cm]?js$ sencha.js
sencha.min.cjs
sencha.mjs
Sencha
Sentry \.sentryclirc$ .sentryclirc Sentry
Semantic Release .*\.releaserc(.js(on)?\|.y(a)?ml)?$ .releaserc
.releaserc.js
.releaserc.json
.releaserc.yml
Semantic Release
Semantic Release Config ^release\.config\.js$ release.config.js Semantic Release Config
Serverless (^\|\.)serverless\.ya?ml$ serverless.yml
.serverless.yaml
Serverless
Service Fabric .*\.sfproj$ *.sfproj Service Fabric
Settings .*\.(settings?\|options?\|opts?)$ *.setting
*.settings
*.option
*.options
*.opt
*.opts
Settings
Sequelize ^\.sequelizerc(\.[cm]?js\|\.json)?$ .sequelizerc
.sequelizerc.js
.sequelizerc.cjs
.sequelizerc.json
Sequelize
Shadow CLJS ^shadow-cljs\.edn$ shadow-cljs.edn Shadow CLJS
Shen .*\.shen$ *.shen Shen
Shellcheck ^\.?shellcheckrc$ .shellcheckrc
shellcheckrc
Shellcheck
Shell .*\.(sh\|zsh\|fish\|bash\|tcsh)(rc)?$ *.sh
*.zsh
*.fish
*.bash
.fishrc
.zshrc
.bashrc
.tcsh
Shell
Shell (2) .*\.(csh\|ksh\|mksh\|pdksh)(rc)?$ *.csh
*.ksh
*.mksh
*.pksh
.cshrc
.kshrc
.mkshrc
.pdkshrc
Shell (2)
Shell History \.((irb-\|bash_\|fish)history\|lesshst)$ .irb-history
.bash_history
.lesshst
Shell History
Shipit ^shipitfile(\b.+)?\.[cm]?js$ shipitfile.cjs
shipitfile.js
shipitfile.mjs
Shipit
Shippable ^shippable\.ya?ml$ shippable.yml
shippable.yaml
Shippable
Sigils .*\.sigils$ *.sigils Sigils
SilverStripe .*\.ss$ *.ss SilverStripe
Sketch .*\.sketch$ *.sketch Sketch
SketchUp Layout .*\.layout$ *.layout SketchUp Layout
SketchUp Make .*\.(skp\|style)$ *.skp
*.style
SketchUp Make
Skipper .*\.eskip$ *.eskip Skipper
Slang .*\.slang$ *.slang Slang
Slash .*\.sl$ *.sl Slash
Slice .*\.ice$ *.ice Slice
Slim .*\.slim$ *.slim Slim
SmartOS ^smartos.*$ smartos.iso
smartos.deb
SmartOS
Smarty .*\.tpl$ *.tpl Smarty
Snapcraft ^snapcraft\.ya?ml$ snapcraft.yml
snapcraft.yaml
Snapcraft
Snap.svg ^snap\.svg([-.]min)?\.[cm]?js$ snap.svg.min.js
snap.svg-min.js
snap.svg.cjs
snap.svg.mjs
Snap.svg
Snapshots .*\.snap$ *.snap Snapshots
Snort .*\.snort$ *.snort Snort
Snowpack ^snowpack\.config\.(js\|ts)$ snowpack.config.js
snowpack.config.ts
Snowpack
Snyk .*\.snyk$ *.snyk Snyk
Solidity .*\.sol(idity)?$ *.sol
*.solidity
Solidity
Solidarity ^\.solidarity(\.json)?$ .solidarity.json Solidarity
Sonar .*\.sonarrc$ *.sonarrc Sonar
Sophia .*\.aes$ *.aes Sophia
Sorbet .*\.rbi$ *.rbi Sorbet
Sourcemap .*\.(map\|mapping\|enigma\|cidmap\|tiny(v2)?\|match)$ *.map
*.mapping
*.enigma
*.cidmap
*.tiny
*.tinyv2
*.match
Sourcemap
SpaceEngine .*\.spe$ *.spe SpaceEngine
Spacemacs (^\|\.)spacemacs$ spacemacs
.spacemacs
Spacemacs
SparQL ^.*\.rq$ *.rq SparQL
Spray ^(reference\|application)\.conf$ reference.conf
application.conf
Spray
Spring .*\.spring$ *.spring Spring
SQF .*\.[hs]qf$ *.sqf
*.hqf
SQF
SQL .*\.(sql\|pdb\|pgsql\|mysql\|hql\|qml\|psql\|pkb\|xql\|xq\|xqm\|xqy\|cql\|prc\|viw)$ *.sql
*.pdb
*.pgsql
*.mysql
*.hql
*.qml
*.psql
*.pkb
*.xql
*.xq
*.xqm
*.xqy
*.cql
*.prc
*.viw
SQL
SQLite .*\.sqlite3?$ *.sqlite
*.sqlite3
SQLite
SquareSpace .*\.jsont$ *.jsont SquareSpace
Squirrel .*\.g?nut$ *.nut
*.gnut
Squirrel
Stan .*\.stan$ *.stan Stan
Stata .*\.(stata\|do\|ado\|oh\|ihlp\|matah?\|sthlp)$ *.stata
*.do
*.ado
*.oh
*.ihlp
*.sthlp
*.mata
*.matah
Stata
StdLibJS ^stdlib(-.+)?\.[cm]?js stdlib.js
stdlib.mjs
stdlib.conf.cjs
StdLibJS
Stencil Config ^stencil\.config\.(js\|ts)$ stencil.config.js
stencil.config.ts
Stencil Config
Stencil .*\.stencil$ *.stencil Stencil
Stitches ^\.?stitches.config\.([cm]?js\|ts)$ stitches.config.ts
.stitches.config.cjs
.stitches.config.js
Stitches
Storyboard .*\.storyboard$ *.storyboard Storyboard
Storyist .*\.story$ *.story Storyist
Storybook .*\.(story\|stories)\.(jsx?\|tsx?)$ *.story.js
*.stories.js
*.story.jsx
*.stories.ts
*.stories.tsx
Storybook
Stylelint ^(\.stylelintrc(\.([cm]?js\|json\|ya?ml))?\|stylelint\.config\.js(on)?)$ .stylelintrc
stylelint.config.js
stylelint.config.json
.stylelintrc.js
.stylelintrc.json
.stylelintrc.yaml
Stylelint
Stylelint Ignore \.stylelintignore(\.json)?$ .stylelintignore
.stylelintignore.json
Stylelint Ignore
Stylable .*\.st\.css$ *.st.css Stylable
Styled Components .*\.sc\.(js\|jsx\|ts\|tsx\|mjs\|cjs)$ *.sc.js
*.sc.jsx
*.sc.ts
*.sc.tsx
*.sc.mjs
*.sc.cjs
Styled Components
Styled Components (2) .*\.styled$ *.styled Styled Components (2)
Stylish Haskell ^\.stylish-haskell\.ya?ml$ .stylish-haskell.yml
.stylish-haskell.yaml
Stylish Haskell
Stylus .*\.styl$ *.styl Stylus
Sublime .*\.sublime-.* *.sublime-workspace
*.sublime-package
Sublime
Subtitles .*\.(srt\|sub)$ *.srt
*.sub
Subtitles
SuperCollider .*\.scd$ *.scd SuperCollider
SugarSS .*\.sss$ *.sss SugarSS
Svelte .*\.svelte *.svelte Svelte
Svelte Config svelte\.config\.js(on)? svelte.config.js
svelte.config.json
Svelte Config
SVN ^\.svn(ignore)? .svn
.svnignore
SVN
Swagger .*\.(swagger\|swag)$ *.swagger
*.swag
Swagger
Swagger Config ((swagger\|api)\.(yml\|yaml\|json))$ swagger.yml
swagger.yaml
swagger.json
api.yml
api.yaml
api.json
Swagger Config
SWC .*\.swc$ *.swc SWC
Swift .*\.swift$ *.swift Swift
Swift Lock package\.pins$ package.pins Swift Lock
Swig .*\.swig$ *.swig Swig
Symfony ^symfony\.lock$ symfony.lock Symfony
Table of Contents .*\.(toc\|listing)$ *.toc
*.listing
Table of Contents
Tags .*\.(c\|gem\|hg\|local)?tags$ *.tags
*.ctags
*.gemtags
*.hgtags
*.localtags
Tags
Tags (2) .*\.(pid\|tld\|sha(256\|sum))$ *.tags
*.ctags
*.gemtags
*.hgtags
*.localtags
Tags (2)
Tailwind CSS Config ^\.?tailwind.*\.[cm]?[jt]s$ tailwind.js
tailwind.conf.js
*.tailwind.cjs
config.tailwind.mjs
Tailwind CSS Config
TCL .*\.(tcl\|adp\|tm\|exp\|tkcvs\|tkdiffrc)$ *.tcl
*.adp
*.tm
*.exp
*.tkvcs
*.tkdiffrc
TCL
Tea .*\.tea$ *.tea Tea
Teal .*\.teal$ *.teal Teal
Telegram .*\.(tl\|xps)$ *.tl
*.xps
Telegram
Template Toolkit .*\.tt[234]?$ *.tt
*.tt2
*.tt3
*.tt4
Template Toolkit
Tera .*\.tera$ *.tera Tera
TerraForm .*\.(tf\|tfstate\|tfvars)(\.json)?$ *.tf
*.tfstate
*.tfvars
*.tf.json
TerraForm
Terser .*\.(terser\|uglify)rc(\.\w+)?$ *.terserrc
*.uglifyrc.json
*.terserrc.conf
Terser
Tern .*\.tern-(config\|project)$ *.tern-config
*.tern-project
Tern
Tern Config ^\.ternconfig$ .ternconfig Tern Config
TestCafe ^\.testcaferc\.json$ .testcaferc.json TestCafe
Test Coffee .*\.?(test\|spec)\.coffee$ *.test.coffee
*.spec.coffee
Test Coffee
Test Dart .*\.?(test\|spec)\.dart$ *.test.dart
*.spec.dart
Test Dart
Test Go .*([._])(test\|spec)\.go$ *.test.go
*.spec.go
*_test.go
*_spec.go
Test Go
Test Haskell .*\.?(test\|spec)\.hs$ *.test.hs
*.spec.hs
Test Haskell
Test Java ([tT])est\.java$ MyTest.java
myTest.java
mytest.java
Test Java
Test JS .*\.?(test\|spec)\.[cm](js\|es6)$ *.test.js
*.spec.js
*.test.es6
*.spec.es6
*.test.mjs
*.spec.cjs
Test JS
Test Perl .*\.?(test\|spec)\.(perl\|pl[x6]?\|pm6?\|ph\|al\|psgi)$ *.test.perl
*.spec.pl
*.test.pl6
*.test.pm6
*.spec.ph
Test Perl
Test React .*\.?(test\|spec)\.(jsx\|tsx)$ *.test.jsx
*.spec.jsx
*.test.tsx
*.spec.tsx
Test React
Test Python .*\.(test\|spec)\.(py\|ipy\|python\|py[pt3iwzc]\|whl\|pep)$ *.test.py
*.spec.ipy
*.test.python
*.spec.whl
*.test.pep
Test Python
Test Ruby .*([_.])(test\|spec)\.(rb\|rbs\|ruby)$ *.test.rb
*.spec.rbs
my_test.ruby
controller_spec.rb
Test Ruby
Test Rust .*\.?(test\|spec)\.rs$ *.test.rs
*.spec.rs
Test Rust
Test TypeScript .*\.?(test\|spec)\.ts$ *.test.ts
*.spec.ts
Test TypeScript
TeX .*\.(tex\|ltx\|aux\|sty\|dtx\|lbx\|mkiv\|mkvi\|mkii\|pgf\|tikz\|texi\|txi)$ *.tex
*.ltx
*.aux
*.sty
*.dtx
*.lbx
*.mkiv
*.mkvi
*.mkii
*.pgf
*.tikz
*.txi
*.texi
TeX
Textile .*\.textile$ *.textile Textile
TextMate .*\.tm(cg\|Preferences\|Properties\|Theme\|Language\|Command\|Snippet\|Macro) *.tmcg
*.tmPreferences
*.tmProperties
*.tmTheme
*.tmLanguage
*.tmCommand
*.tmSnippet
*.tmMacro
TextMate
Thor .*\.thor$ *.thor Thor
Tilt ^[Tt]iltfile$ Tiltfile
tiltfile
Tilt
TinyMCE ^tinymce(\.min)?\.[cm]?[jt]s tinymce.js
tinymce.ts
tinymce.min.cjs
tinymce.min.mjs
TinyMCE
Tipe .*\.tipe$ *.tipe Tipe
TLA+ .*\.tla$ *.tla TLA+
Tmux (\.\|_\|^)tmux\.conf$ *.tmux.conf
test_tmux.conf
tmux.conf
Tmux
Truffle ^\.truffle\.[cm]?js$ .truffle.cjs
.truffle.js
.truffle.mjs
Truffle
TTCN-3 .*\.ttcn3?$ *.ttcn
*.ttcn3
TTCN-3
Tomcat ^tomcat.* tomcat.conf
tomcat.java
Tomcat
TOML .*\.toml$ *.toml TOML
TODO ^(TODO\|todo).* TODO
todo
TODO.md
todo.js
TODO.java
TODO
Todofile .*\.(todo\|taskpaper)$ *.todo
*.taskpaper
Todofile
Tox ^tox\.ini$ tox.ini Tox
TSConfig \.?tsconfig.*\.(js\|json)$ tsconfig.js
tsconfig.json
.tsconfig.js
.tsconfig.json
TSConfig
TSLint \.?tslint.*\.(js\|json\|ya?ml)$ tslint.js
tslint.json
.tslint.js
.tslint.json
tslint.yaml
.tslint.yml
TSLint
Travis .*\.travis\.yml$ *.travis.yml Travis
TUC .*\.tuc$ *.tuc TUC
Turing .*\.tu$ *.tu Turing
Twig .*\.twig$ *.twig Twig
TwineScript .*\.tw$ *.tw TwineScript
TXL .*\.txl$ *.txl TXL
TypeDoc ^typedoc\.js(on)?$ typedoc.json
typedoc.js
TypeDoc
Typescript Defs .*\.d\.ts$ *.d.ts Typescript Defs
Typings ^typings\.json$ typings.json Typings
TypoScript .*\.typoscript$ *.typoscript TypoScript
UFO .*\.(glif\|ufoz?) *.glif
*.ufo
*.ufoz
UFO
UiKit ^uikit(\.min)?\.[cm]?js$ uikit.js
uikit.min.js
uikit.cjs
uikit.mjs
UiKit
UML .*\.(uml\|iuml\|puml\|pu\|plantuml\|wsd) *.uml
*.iuml
*.puml
*.pu
*.plantuml
*.wsd
UML
Unicode .*\.(ldml\|unicode) *.ldml
*.unicode
Unicode
UnibeautifyRC .unibeautifyrc(\.(ya?ml\|json\|[cm]?js))?$ .unibeautifyrc
.unibeautifyrc.yml
.unibeautifyrc.json
.unibeautifyrc.js
UnibeautifyRC
Unibeautify Config unibeautify\.config\.(ya?ml\|json\|[cm]?js)$ unibeautifyrc.config.js
unibeautify.config.json
unibeautify.config.yaml
Unibeautify Config
Unity .*\.(unity(3d\|proj\|package)?\|fbx\|u3d\|ply\|anim\|asset\|cubemap\|mat\|meta\|prefab) *.unity
*.unity3d
*.unityproj
*.unitypackage
*.u3d
*.ply
*.fbx
*.anim
*.asset
*.cubemap
*.mat
*.meta
*.prefab
Unity
Uniform Office .*\.uo[ftsp]$ *.uos
*.uof
*.uot
*.uop
Uniform Office
Unlicense ^(unlicen[cs]e\|UNLICEN[CS]E)(\.(txt\|md))?$ unlicense
UNLICENSE
UNLICENCE.txt
unlicence.md
Unlicense
UNO .*\.uno$ *.uno UNO
Unreal .*\.(u\|unr\|utx\|umx\|uax\|ukx\|uz\|upkg\|uc\|upl\|asc\|lwo\|uasset)$ *.u
*.unr
*.utx
*.umx
*.uax
*.ukx
*.uz
*.upkg
*.uc
*.upl
*.asc
*.lwo
*.uasset
Unreal
UrWeb .*\.(urs?)$ *.ur
*.urs
UrWeb
V .*\.(v\|vh)$ *.v
*.vh
V
V8 \.v8flags.*$ .v8flags
.v8flags.3.14.5.9.Ciel
V8
Vagrant ^([Vv])agrantfile$ Vagrantfile
vagrantfile
Vagrant
Vala .*\.(vala\|vapi)$ *.vala
*.vapi
Vala
Vapor ^vapor\.ya?ml$ vapor.yml
vapor.yaml
Vapor
Varnish .*\.(vcl)$ *.vcl Varnish
Vash .*\.vash$ *.vash Vash
Velocity .*\.(vm\|vtl\|fhtml) *.vm
*.vtl
*.fhtml
Velocity
Vercel ^vercel\.json$ vercel.json Vercel
Vercelignore ^\.vercelignore$ .vercelignore Vercelignore
Verilog .*\.(sv\|veo)$ *.veo
*.sv
Verilog
VERSION ^(VERSION\|version)$ VERSION
version
VERSION
VHDL .*\.(vhdl\|vh[dfiostw]\|sv)$ *.vhdl
*.vhd
*.vhf
*.vhi
*.vho
*.vhs
*.vht
*.vhw
*.sv
VHDL
Vim .*\.(vim\|viml\|vimrc\|gvimrc)$ *.vim
*.viml
*.vimrc
*.gvimrc
Vim
Visio .*\.(vsd[mx]\|vd[wx]\|vs[dwxlst]\|vtx\|vrd)$ *.vsdm
*.vsdx
*.vdx
*.vdw
*.vsd
*.vsw
*.vsx
*.vsl
*.vss
*.vst
*.vrd
*.vtx
Visio
Visual Basic .*\.(vba?\|bas(ic)?\|vbhtml\|vbs)$ *.vb
*.vba
*.bas
*.basic
*.vbhtml
*.vbs
Visual Basic
Visual Basic Project .*\.vbproj$ *.vbproj Visual Basic Project
Visual Studio .*\.(vssettings\|vstemplate\|lsproj\|modelproj\|njsproj\|wmaproj\|sln\|suo)$ *.vssettings
*.vstemplate
*.lsproj
*.modelproj
*.njsproj
*.wmaproj
*.sln
*.suo
Visual Studio
Vite ^vite\.config\.[jt]s$ vite.config.js
vite.config.ts
Vite
VirtualBox .*\.(vbox\|vdi\|vhdx\|vbox_version)$ *.vbox
*.vdi
*.vbox_version
*.vhdx
VirtualBox
VMWare .*\.(vmxf?\|vmdk\|nvram\|vms[dns]\|vmware\|vswp\|vmtx)$ *.vmx
*.vmxf
*.vmdk
*.nvram
*.vmware
*.vmsd
*.vmsn
*.vmss
*.vswp
*.vmtx
VMWare
Volt .*\.volt$ *.volt Volt
V-Ray .*\.(vray\|vrimg)$ *.vray
*.vrimg
V-Ray
VSCode Extension .*\.vsix(manifest)?$ *.vsix
*.vsixmanifest
VSCode Extension
VSCode .*\.(vscode\|code-workspace)$ *.vscode
.code-workspace
VSCode
VSCode Settings ^(launch\|extensions\|tasks\|settings)\.json$ launch.json
extensions.json
tasks.json
settings.json
VSCode Settings
VSCode Ignore \.vscodeignore(\.json)?$ .vscodeignore
.vscodeignore.json
VSCode Ignore
VSTS ^\.?vsts-ci\.ya?ml$ .vsts-ci.yml
vsts-ci.yaml
VSTS
VSTS Ignore ^\.tfignore$ .tfignore VSTS Ignore
Vue .*\.vue$ *.vue Vue
Vue Config ^vue\.config\.[cm]?js$ vue.config.js
vue.config.mjs
vue.config.cjs
Vue Config
Vue RC ^\.vuerc$ .vuerc Vue RC
Vuex .*\.vuex$ *.vuex Vuex
Vyper .*\.vy$ *.vy Vyper
W3C ^w3c\.json$ w3c.json W3C
Wallaby ^\.wallaby\.[jt]s$ .wallaby.js
.wallaby.ts
Wallaby
Walt ^\.walt$ .walt Walt
Watchman (\.watchmanconfig\|^watchman\.json)$ .watchmanconfig
watchman.json
Watchman
Warcraft 3 .*\.(wc3\|jass\|zn)$ *.wc3
*.jass
*.zn
Warcraft 3
WebAssembly .*\.(wat\|wasm\|wast)$ *.wat
*.wasm
*.wast
WebAssembly
WDL .*\.wdl$ *.wdl WDL
Web2PY .*\.web2py$ *.web2py Web2PY
WebGL .*\.webgl$ *.webgl WebGL
Web Ontology Language .*\.owl$ *.owl Web Ontology Language
Webpack ^webpack\.(common\|config\|dev\|prod)\.(js\|es\|es6\|coffee\|ts)$ webpack.common.js
webpack.config.js
webpack.dev.js
webpack.prod.js
webpack.config.ts
webpack.config.es6
webpack.dev.coffee
Webpack
WebVTT .*\.vtt$ *.vtt WebVTT
Webhint .*\.hintrc$ *.hintrc Webhint
Wenyan .*\.wy$ *.wy Wenyan
WePy .*\.wpy$ *.wpy WePy
WebP .*\.webp$ *.webp WebP
Wercker wercker\.ya?ml$ wercker.yaml
wercker.yml
Wercker
Wget ^\.wget(rc\|-hsts)$ .wgetrc
.wget-hsts
Wget
Windi.css ^windi\.config\.[tj]s$ windi.config.js
windi.config.ts
Windi.css
Windows .*\.(bat\|exe\|ms\|msi\|reg\|msc)$ *.bat
*.exe
*.ms
*.msi
*.reg
*.msc
Windows
WinUI .*\.(xaml\|baml)$ *.xaml
*.baml
WinUI
Wix .*\.(wix\|wxl\|wxi\|wixobj\|wixproj)$ *.wix
*.wixproj
*.wixobj
*.wxi
*.wxl
Wix
Word .*\.(doc\|docx\|docm\|docxml\|dotm\|dotx\|wri\|odt\|odtx)$ *.doc
*.docx
*.docm
*.docxml
*.dotm
*.dotx
*.wri
*.odt
*.odtx
Word
Wolfram Language .*\.wl[st]?$ *.wl
*.wls
*.wlt
Wolfram Language
Wordpress ^wp-.*\.php$ wp-admin.php
wp-login.php
wp-config.php
Wordpress
Workbox workbox-config\.[jt]s$ workbox-config.js
workbox-config.ts
Workbox
WPML ^wpml-config\.xml$ wpml-config.xml WPML
WurstScript .*\.wurst$ *.wurst WurstScript
WeiXin Styles .*\.wxss$ *.wxss
*.wxs
*.wxml
WeiXin Styles
WeiXin Markup .*\.wxml$ *.wxml WeiXin Markup
WeiXin Service .*\.wxs$ *.wxs WeiXin Service
X10 .*\.x10 *.x10 X10
X11 ^\.X(authority\|clients\|initrc\|inputrc\|profile\|resources\|session-errors\|screensaver)$ .Xauthority
.Xclients
.Xinitrc
.Xinputrc
.Xprofile
.Xresources
.Xscreensaver
X11
Xamarin ^\.workbook$ .workbook Xamarin
XC .*\.xc$ *.xc XC
XCode .*\.xcodeproj$ *.xcodeproj XCode
XCode Files .*\.xc(playground\|workspace\|workspacedata\|plugindata\|checkout\|scheme\|settings\|userstate)$ *.xcplayground
*.xcworkspace
*.xcworkspacedata
*.xcplugindata
*.xcscheme
*.xcsettings
*.xcuserstate
XCode Files
XCode Mode v3 .*\.mode\dv3$ *.mode1v3
*.mode3v3
XCode Mode v3
Xib .*\.xib$ *.xib Xib
XLIFF .*\.(xliff\|xlf)$ *.xliff
*.xlf
XLIFF
XMake ^xmake\.lua$ xmake.lua XMake
Xtend .*\.xtend$ *.xtend Xtend
Xojo .*\.xojo_(code\|menu\|report\|script\|toolbar\|window)$ *.xojo_code
*.xojo_menu
*.xojo_report
*.xojo_script
*.xojo_toolbar
*.xojo_window
Xojo
XPages .*\.xsp(-config\|\.metadata)$ *.xsp-config
*.xsp.metadata
XPages
XQuery .*\.xquery$ *.xquery XQuery
XProc .*\.(xpl\|xproc)$ *.xpl
*.xproc
XProc
XUbuntu xubuntu.*$ xubuntu.iso
xubuntu.deb
XUbuntu
Yamllint ^\.yamllint(\.ya?ml)?$ .yamllint.yml
.yamllint.yml
.yamllint
Yamllint
Yandex Yaspeller ^\.(yaspellerrc\|yaspeller\.json)$ .yaspellerrc
.yaspeller.json
Yandex Yaspeller
Yang .*\.yang$ *.yang Yang
YARA .*\.yara?$ *.yar
*.yara
YARA
Yarn (\.yarnrc\|yarn.js(on)?) .yarnrc
yarn.json
yarn.js
Yarn
Yarn Lock ^yarn\.lock$ yarn.lock Yarn Lock
Yarn Clean ^\.yarn(clean\|-metadata\|-integrity)$ .yarnclean
.yarn-metadata
.yarn-integrity
Yarn Clean
Yard \.yardopts$ .yardopts Yard
YASM .*\.yasm$ *.yasm YASM
Yeoman ^\.yo-rc\.json$ .yo-rc.json Yeoman
Yorick .*\.yorick$ *.yorick Yorick
YUI ^(yahoo-\|yui)[^.]*\.[jt]s$ yahoo-config.js
yui.js
yui-min.js
YUI
YVM ^\.yvmrc$ .yvmrc YVM
ZBrush .*\.(zpr\|ztl)$ *.zpr
*.ztl
ZBrush
Zeit Now ^now\.json$ now.json Zeit Now
Zephir .*\.(zep\|zephir)$ *.zep
*.zephir
Zephir
Zig .*\.zig$ *.zig Zig
Zilog .*\.(z80\|zilog\|plx)$ *.z80
*.zilog
*.plx
Zilog
Zimpl .*\.(zpl\|zmpl\|zimpl)$ *.zpl
*.zmpl
*.zimpl
Zimpl
ZorinOS zorinos.*$ zorinos.iso
zorinos.deb
ZorinOS
Zork Assembly .*\.(zap\|xzap\|zabstr\|zil\|mud)$ *.zap
*.xzap
*.zabstr
*.zil
*.mud
Zork Assembly
ZenScript Craft Tweaker .*\.zs$ *.zs ZenScript Craft Tweaker
ZenScript Craft Tweaker Config ^.*\.zsrc\.json$ *.zsrc.json ZenScript Craft Tweaker Config
Preferences .*\.(ldif\|lds?\|ini\|cnf\|config\|cfg\|mcf\|kys)$ *.ld
*.ldif
*.lds
*.ld
*.ini
*.cnf
*.config
*.cfg
*.mcf
*.kys
Preferences
Envs .*\.env(\.\w+)?$ *.env
*.env.dev
*.env.prod
Envs
Configs ^(config\|settings?\|options?\|prefs?)(\.(ya?ml\|ini\|txt\|json))?$ config
settings
option
pref
config.yml
settings.ini
option.txt
prefs.yaml
config.json
Configs
Prefs .*\.(prefs?)$ *.pref
*.prefs
Prefs
Git ^\.git.* .git
.git-submodules
.gitrc
Git
Binary ^[^.]+$ ls
cd
myapp
run
Binary
Binary (2) .*\.(axf\|elf\|la\|objdump\|bsdiff\|bin\|dat\|pak\|db-journal)$ *.axf
*.elf
*.la
*.objdump
*.bsdiff
*.bin
*.dat
*.pak
*.db-journal
Binary (2)
Binary (3) .*\.(gco?\|gcode\|[cdhk]nc\|prx\|swp\|rnd)$ *.gc
*.gco
*.gcode
*.cnc
*.dnc
*.hnc
*.knc
*.prx
*.swp
*.rnd
Binary (3)
Archive .*\.(z\|xz\|7z\|7zip\|gzip\|zip\|rar\|tar)$ *.z
*.xz
*.7z
*.7zip
*.gzip
*.zip
*.rar
*.tar
Archive
Archive (2) .*\.(gz\|pzip\|saz\|tgz\|bz2\|xar\|egg\|sit)$ *.gz
*.pzip
*.saz
*.tgz
*.bz2
*.egg
*.xar
*.sit
Archive (2)
Archive (3) .*\.(lzo?\|lzma\|tlz\|iso\|hqx\|whl\|xar\|ear\|egg\|sit\|hak)$ *.lz
*.lzo
*.lzma
*.tlz
*.iso
*.whl
*.hqx
*.xar
*.ear
*.egg
*.sit
*.hak
Archive (3)
Audio .*\.(mp3\|aac\|aiff\|au\|flac\|m4a\|mpc\|mp\|mka\|son)$ *.mp3
*.aac
*.aiff
*.au
*.flac
*.m4a
*.mpc
*.mp
*.mka
*.son
Audio
Audio (2) .*\.(mpp\|ogg\|oga\|opus\|ra\|rm\|wav\|wma\|snd\|mid\|cda)$ *.mpp
*.ogg
*.oga
*.opus
*.ra
*.rm
*.wav
*.wma
*.snd
*.mid
*.cda
Audio (2)
Audio (3) .*\.(ac3\|m4p\|f4a\|f4b\|it\|s3m\|sndh)$ *.ac3
*.m4p
*.f4a
*.f4b
*.it
*.s3m
*.sndh
Audio (3)
Video .*\.(avi\|mp4\|m4v\|mpg\|mpeg\|mov\|mkv\|flv\|h264)$ *.avi
*.mp4
*.m4v
*.mpg
*.mpeg
*.mov
*.mkv
*.flv
*.h264
Video
Video (2) .*\.(webm\|wmv\|ogv\|3gp\|m4v\|3gpp\|ogm\|dvd\|divx\|qt\|yuv)$ *.webm
*.wmv
*.ogv
*.3gp
*.m4v
*.3gpp
*.ogm
*.dvd
*.divx
*.qt
*.yuv
Video (2)
Video (3) .*\.(asx\|asf\|mks\|mk3d\|ogg)$ *.asx
*.asf
*.mks
*.mk3d
*.ogg
Video (3)
Clojure .*\.(clj[cxs]?\|clojure\|hic\|rg)$ *.cljs
*.clj
*.cljc
*.cljx
*.clojure
*.hic
*.rg
Clojure
DLang .*\.di?$ *.d
*.di
DLang
CSS .*\.(css\|tss)$ *.css
*.tss
CSS
HTML .*\.(html\|htm\|xhtml\|mhtml\|dtml\|kit\|latte\|isml\|scaml)$ *.html
*.htm
*.xhtml
*.mhtml
*.dtml
*.kit
*.latte
*.isml
*.scaml
HTML
Go .*\.(go\|gohtml)$ *.go
*.gohtml
Go
Javascript Minified .*\.min\.(js\|es6\|es\|jsx\|ts)$ *.min.js
*.min.es6
*.min.es
*.min.jsx
*.min.ts
Javascript Minified
Java .*\.(java\|jar\|war)$ *.java
*.jar
*.war
Java
JSX .*\.(jsx\|tsx)$ *.jsx
*.tsx
JSX
Javascript .*\.([cm]?js\|es\d)$ *.js
*.es6
*.mjs
*.cjs
Javascript
JSON .*\.(json\|cson\|jsonc\|rsj\|ndjson\|ejson\|ston)$ *.json
*.cson
*.jsonc
*.rsj
*.rdjson
*.ejson
*.ston
JSON
Kotlin .*\.(kt\|ktm\|kotlin)$ *.kt
*.ktm
*.kotlin
Kotlin
KotlinScript .*\.kts$ *.kts KotlinScript
Less .*\.less$ *.less Less
Lua .*\.(lua\|pd_lua\|rbxs\|wlua\|luacheckrc\|rockspec)$ *.lua
*.pd_lua
*.wlua
*.rbxs
*.luacheckrc
*.rockspec
Lua
nginx .*\.(nginx\|conf)$ *.nginx
*.conf
nginx
Perl .*\.(perl\|pl[x6]?\|pm6?\|ph\|al\|psgi)$ *.perl
*.pl
*.pl6
*.pm
*.plx
*.pm
*.pm6
*.al
*.ph
*.psgi
Perl
PHP .*\.(php[st0-9]?)$ *.php
*.phps
*.phpt
*.php0
*.php1
*.php2
*.php3
*.php6
PHP
Python .*\.(py\|ipy\|python\|py[pt3iwzc]\|whl\|pep)$ *.py
*.python
*.ipy
*.pyc
*.whl
*.pep
*.pyp
*.pyt
*.py3
*.pyi
*.pyw
*.pyz
Python
Python 2 .*\.(pyde\|gypi?\|tac\|xpy\|wsgi\|smk\|rpy)$ *.pyde
*.gypi
*.gyp
*.tac
*.xpy
*.smk
*.rpy
Python 2
Ruby .*\.(rb\|ruby\|rabl)$ *.rb
*.ruby
*.rabl
Ruby
SASS .*\.(sass\|scss)(rc\.[cm]?js)?$ *.sass
*.scss
.sassrc.js
.scssrc.cjs
SASS
Text .*\.(txt\|rtf\|abt\|ans\|brf\|dri\|no\|lcov)$ *.txt
*.rtf
*.abt
*.ans
*.brf
*.dri
*.no
*.lcov
Text
TypeScript .*\.(ts\|tslint)$ *.ts
*.tslint
TypeScript
Class .*\.(class\|o\|out\|ko\|py[oc])$ *.class
*.o
*.out
*.ko
*.pyo
*.pyc
Class
DB .*\.(dbi?\|ddl\|dict?\|od\|schema\|db[23]\|edn\|sy\|2da)$ *.db
*.dbi
*.ddl
*.dic
*.dict
*.od
*.schema
*.db2
*.db3
*.edn
*.sy
*.2da
DB
DB (2) .*\.(aff\|fea\|cbor\|pytb\|son\|syntax\|tgn\|od\|onlydata\|eign)$ *.aff
*.fea
*.cbor
*.pytb
*.son
*.syntax
*.tgn
*.od
*.onlydata
*.eign
DB (2)
DB (3) .*\.(term(cap\|info)\|icondb\.js)$ *.termcap
*.terminfo
*.icondb.js
DB (3)
Font .*\.(ttf\|ttc\|pfb\|pfm\|otf\|dfont\|pfa\|eot\|woff2?\|tfm\|dfont)$ *.ttf
*.ttc
*.pfb
*.pfm
*.otf
*.dfont
*.pfa
*.eot
*.woff
*.woff2
*.tfm
*.dfont
Font
Lockfiles .*\.lock$ *.lock Lockfiles
Markdown .*\.(md\|markdown\|mk?down\|mkd\|pmd\|jmd)$ *.md
*.markdown
*.mdown
*.mkdown
*.mkd
*.pmd
*.jmd
Markdown
XML .*\.(xml\|fxml\|jrxml\|jnlp\|pom\|rng\|tld\|wsdl\|xsd\|xsl\|xslt\|xul)$ *.xml
*.fxml
*.jrxml
*.jnlp
*.pom
*.rng
*.tld
*.wsdl
*.xsd
*.xsl
*.xslt
*.xul
XML
YAML .*\.(yml\|yaml\|info)$ *.yml
*.yaml
*.info
YAML