Repository: tlienart/Franklin.jl
Pull request #344 (2020-01-22 15:42:17)

removing occurences of judoc in  code
context #340 

codecov[bot]: # [Codecov](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=h1) Report
> Merging [#344](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=desc) into [master](https://codecov.io/gh/tlienart/Franklin.jl/commit/8187523452bdefc452936a2f714d9775c7ee3c51?src=pr&el=desc) will **not change** coverage.
> The diff coverage is `66.66%`.

[![Impacted file tree graph](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/graphs/tree.svg?width=650&token=6aP21CmJcY&height=150&src=pr)](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=tree)

```diff
@@           Coverage Diff           @@
##           master     #344   +/-   ##
=======================================
  Coverage   89.05%   89.05%           
=======================================
  Files          31       31           
  Lines        1836     1836           
=======================================
  Hits         1635     1635           
  Misses        201      201
```


| [Impacted Files](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [src/manager/post\_processing.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL21hbmFnZXIvcG9zdF9wcm9jZXNzaW5nLmps) | `49.07% <ø> (ø)` | :arrow_up: |
| [src/converter/md.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2NvbnZlcnRlci9tZC5qbA==) | `100% <ø> (ø)` | :arrow_up: |
| [src/converter/js\_prerender.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2NvbnZlcnRlci9qc19wcmVyZW5kZXIuamw=) | `59.57% <ø> (ø)` | :arrow_up: |
| [src/jd\_paths.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2pkX3BhdGhzLmps) | `100% <ø> (ø)` | :arrow_up: |
| [src/converter/html.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2NvbnZlcnRlci9odG1sLmps) | `99.13% <ø> (ø)` | :arrow_up: |
| [src/Franklin.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL0ZyYW5rbGluLmps) | `100% <ø> (ø)` | :arrow_up: |
| [src/jd\_vars.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2pkX3ZhcnMuamw=) | `100% <ø> (ø)` | :arrow_up: |
| [src/integration/literate.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL2ludGVncmF0aW9uL2xpdGVyYXRlLmps) | `100% <ø> (ø)` | :arrow_up: |
| [src/manager/file\_utils.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL21hbmFnZXIvZmlsZV91dGlscy5qbA==) | `78.18% <0%> (ø)` | :arrow_up: |
| [src/manager/franklin.jl](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree#diff-c3JjL21hbmFnZXIvZnJhbmtsaW4uamw=) | `50% <100%> (ø)` | |
| ... and [1 more](https://codecov.io/gh/tlienart/Franklin.jl/pull/344/diff?src=pr&el=tree-more) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=footer). Last update [8187523...f8f4cf1](https://codecov.io/gh/tlienart/Franklin.jl/pull/344?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).


Patch:
diff --git a/Project.toml b/Project.toml
index 03f1c59b..c0049c9c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -7,8 +7,8 @@ version = "0.5.0"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
-HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3"
 FranklinTemplates = "3a985190-f512-4703-8d38-2a7944ed5916"
+HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3"
 Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306"
 LiveServer = "16fef848-5104-11e9-1b77-fb7a48bbb589"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
@@ -19,8 +19,8 @@ Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 
 [compat]
 DocStringExtensions = "^0.8"
-HTTP = "^0.8"
 FranklinTemplates = "^0.4"
+HTTP = "^0.8"
 Literate = "^2.0"
 LiveServer = "^0.3"
 NodeJS = "^0.6, ^1"
diff --git a/README.md b/README.md
index 0a5fc6d9..aaee88b3 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://tlienart.github.io/franklindocs/">
-    <img src="https://tlienart.github.io/franklindocs/assets/infra/logoF2.svg" alt="JuDoc" width="150">
+    <img src="https://tlienart.github.io/franklindocs/assets/infra/logoF2.svg" alt="Franklin" width="150">
   </a>
 </div>
 
diff --git a/src/Franklin.jl b/src/Franklin.jl
index 06f5ad60..b5558a12 100644
--- a/src/Franklin.jl
+++ b/src/Franklin.jl
@@ -4,7 +4,7 @@ using FranklinTemplates
 
 using Markdown
 using Markdown: htmlesc
-using Dates # see jd_vars
+using Dates # see fd_vars
 using DelimitedFiles: readdlm
 using OrderedCollections
 using Pkg
@@ -17,10 +17,14 @@ import NodeJS
 import Literate
 import HTTP
 
-export serve, publish, cleanpull, newsite, optimize, jd2html, literate_folder, verify_links
+export serve, publish, cleanpull, newsite, optimize, fd2html,
+       literate_folder, verify_links
 
 export lunr
-export jdf_empty, jdf_lunr, jdf_literate
+
+# -----------------------------------------------------------------------------
+# Legacy with JuDoc
+export jd2html # = fd2html
 
 # -----------------------------------------------------------------------------
 #
@@ -30,7 +34,7 @@ export jdf_empty, jdf_lunr, jdf_literate
 """Big number when we want things to be far."""
 const BIG_INT = typemax(Int)
 
-const JD_ENV = LittleDict(
+const FD_ENV = LittleDict(
     :DEBUG_MODE         => false,
     :FULL_PASS          => true,
     :FORCE_REEVAL       => false,
@@ -112,25 +116,21 @@ include("converter/html_link_fixer.jl")
 # > javascript
 include("converter/js_prerender.jl")
 
-# FILE PROCESSING
-include("jd_paths.jl")
-include("jd_vars.jl")
+# UTILS
+include("utils/paths.jl")
+include("utils/vars.jl")
+include("utils/misc.jl")
+include("utils/html.jl")
+include("utils/errors.jl")
 
 # FILE AND DIR MANAGEMENT
 include("manager/rss_generator.jl")
 include("manager/dir_utils.jl")
 include("manager/file_utils.jl")
-include("manager/judoc.jl")
+include("manager/franklin.jl")
 include("manager/extras.jl")
 include("manager/post_processing.jl")
 
-# MISC UTILS
-include("misc_utils.jl")
-include("misc_html.jl")
-
-# ERROR TYPES
-include("error_types.jl")
-
 # INTEGRATION
 include("integration/literate.jl")
 
diff --git a/src/build.jl b/src/build.jl
index d6e54ebe..55ddcb00 100644
--- a/src/build.jl
+++ b/src/build.jl
@@ -34,8 +34,8 @@ Pre-rendering
 require `katex.min.js`
 - For highlights, we need `node` and also to have the `highlight.js` installed via `npm`.
 =#
-const JD_CAN_PRERENDER = try success(`$NODE -v`); catch; false; end
-const JD_CAN_HIGHLIGHT = try success(`$NODE -e "require('highlight.js')"`); catch;
+const FD_CAN_PRERENDER = try success(`$NODE -v`); catch; false; end
+const FD_CAN_HIGHLIGHT = try success(`$NODE -e "require('highlight.js')"`); catch;
                                  false; end
 
 #=
@@ -44,37 +44,37 @@ Minification
 - Here we check there is python3, and pip3, and then if we fail to import, we try to
 use pip3 to install it.
 =#
-const JD_HAS_PY3    = try success(`$([e for e in split(PY)]) -V`); catch; false; end
-const JD_HAS_PIP3   = try success(`$([e for e in split(PIP)]) -V`); catch; false; end
-const JD_CAN_MINIFY = JD_HAS_PY3 && JD_HAS_PIP3 &&
+const FD_HAS_PY3    = try success(`$([e for e in split(PY)]) -V`); catch; false; end
+const FD_HAS_PIP3   = try success(`$([e for e in split(PIP)]) -V`); catch; false; end
+const FD_CAN_MINIFY = FD_HAS_PY3 && FD_HAS_PIP3 &&
                       try success(`$([e for e in split(PY)]) -m "import css_html_js_minify"`) ||
                           success(`$([e for e in split(PIP)]) install css_html_js_minify`); catch;
                               false; end
 
 #=
 Information to the user
-- what JuDoc couldn't find
+- what Franklin couldn't find
 - that the user should do a `build` step after installing
 =#
-JD_CAN_HIGHLIGHT || begin
-    JD_CAN_PRERENDER || begin
+FD_CAN_HIGHLIGHT || begin
+    FD_CAN_PRERENDER || begin
         println("""✘ Couldn't find node.js (`$NODE -v` failed).
-                → It is required for pre-rendering KaTeX and highlight.js but is not necessary to run JuDoc (cf docs).""")
+                → It is required for pre-rendering KaTeX and highlight.js but is not necessary to run Franklin (cf docs).""")
     end
     println("""✘ Couldn't find highlight.js (`$NODE -e "require('highlight.js')"` failed).
-            → It is required for pre-rendering highlight.js but is not necessary to run JuDoc (cf docs).""")
+            → It is required for pre-rendering highlight.js but is not necessary to run Franklin (cf docs).""")
 end
 
-JD_CAN_MINIFY || begin
-    if JD_HAS_PY3
+FD_CAN_MINIFY || begin
+    if FD_HAS_PY3
         println("✘ Couldn't find css_html_js_minify (`$([e for e in split(PY)]) -m \"import css_html_js_minify\"` failed).\n" *
-                """→ It is required for minification but is not necessary to run JuDoc (cf docs).""")
+                """→ It is required for minification but is not necessary to run Franklin (cf docs).""")
     else
         println("""✘ Couldn't find python3 (`$([e for e in split(PY)]) -V` failed).
-                → It is required for minification but not necessary to run JuDoc (cf docs).""")
+                → It is required for minification but not necessary to run Franklin (cf docs).""")
     end
 end
 
-all((JD_CAN_HIGHLIGHT, JD_CAN_PRERENDER, JD_CAN_MINIFY, JD_HAS_PY3, JD_HAS_PIP3)) || begin
+all((FD_CAN_HIGHLIGHT, FD_CAN_PRERENDER, FD_CAN_MINIFY, FD_HAS_PY3, FD_HAS_PIP3)) || begin
     println("→ After installing any missing component, please re-build the package (cf docs).")
 end
diff --git a/src/converter/html.jl b/src/converter/html.jl
index 012b5177..9065ca9a 100644
--- a/src/converter/html.jl
+++ b/src/converter/html.jl
@@ -1,7 +1,8 @@
 """
 $(SIGNATURES)
 
-Convert a judoc html string into a html string (i.e. replace `{{ ... }}` blocks).
+Convert a Franklin html string into a html string (i.e. replace `{{ ... }}`
+blocks).
 """
 function convert_html(hs::AS, allvars::PageVars; isoptim::Bool=false)::String
     isempty(hs) && return hs
@@ -40,15 +41,15 @@ end
 """
 $SIGNATURES
 
-Return the HTML corresponding to a JuDoc-Markdown string as well as all the page variables.
-See also [`jd2html`](@ref) which only returns the html.
+Return the HTML corresponding to a Franklin-Markdown string as well as all the
+page variables. See also [`fd2html`](@ref) which only returns the html.
 """
-function jd2html_v(st::AbstractString; internal::Bool=false, dir::String="")::Tuple{String,Dict}
+function fd2html_v(st::AbstractString; internal::Bool=false, dir::String="")::Tuple{String,Dict}
     isempty(st) && return st
     if !internal
         FOLDER_PATH[] = isempty(dir) ? mktempdir() : dir
         set_paths!()
-        JD_ENV[:CUR_PATH] = "index.md"
+        FD_ENV[:CUR_PATH] = "index.md"
         def_GLOBAL_LXDEFS!()
         def_GLOBAL_PAGE_VARS!()
     end
@@ -56,7 +57,10 @@ function jd2html_v(st::AbstractString; internal::Bool=false, dir::String="")::Tu
     h = convert_html(m, v)
     return h, v
 end
-jd2html(a...; k...)::String = jd2html_v(a...; k...)[1]
+fd2html(a...; k...)::String = fd2html_v(a...; k...)[1]
+
+# legacy JuDoc
+jd2html = fd2html
 
 """
 $SIGNATURES
@@ -172,7 +176,7 @@ function process_html_cond(hs::AS, allvars::PageVars, qblocks::Vector{AbstractBl
             # current path is relative to /src/ for instance
             # /src/pages/blah.md -> pages/blah
             # if starts with `pages/`, replaces by `pub/`: pages/blah => pub/blah
-            rpath = splitext(unixify(JD_ENV[:CUR_PATH]))[1]
+            rpath = splitext(unixify(FD_ENV[:CUR_PATH]))[1]
             rpath = replace(rpath, Regex("^pages") => "pub")
 
             # compare with β.pages
diff --git a/src/converter/html_functions.jl b/src/converter/html_functions.jl
index 3986ad20..67497beb 100644
--- a/src/converter/html_functions.jl
+++ b/src/converter/html_functions.jl
@@ -18,8 +18,8 @@ end
 """
 $(SIGNATURES)
 
-H-Function of the form `{{ fill vname }}` to plug in the content of a jd-var `vname` (assuming it
-can be represented as a string).
+H-Function of the form `{{ fill vname }}` to plug in the content of a
+franklin-var `vname` (assuming it can be represented as a string).
 """
 function hfun_fill(params::Vector{String}, allvars::PageVars)::String
     # check params
@@ -148,7 +148,7 @@ function hfun_toc(params::Vector{String})::String
     for i = curlvl-1:-1:baselvl
         inner *= "</li></ol>"
     end
-    toc = "<div class=\"jd-toc\">" * inner * "</div>"
+    toc = "<div class=\"franklin-toc\">" * inner * "</div>"
 end
 
 
diff --git a/src/converter/js_prerender.jl b/src/converter/js_prerender.jl
index 0d283d49..2e54bf3b 100644
--- a/src/converter/js_prerender.jl
+++ b/src/converter/js_prerender.jl
@@ -15,7 +15,7 @@ function js_prerender_katex(hs::String)::String
             const katex = require("$(escape_string(joinpath(PATHS[:libs], "katex", "katex.min.js")))");
             """)
     # string to separate the output of the different blocks
-    splitter = "_>jdsplit<_"
+    splitter = "_>fdsplit<_"
 
     # go over each match and add the content to the jsbuffer
     for i ∈ 1:2:length(matches)-1
@@ -54,7 +54,7 @@ function js_prerender_highlight(hs::String)::String
     write(jsbuffer, """const hljs = require('highlight.js');""")
 
     # string to separate the output of the different blocks
-    splitter = "_>jdsplit<_"
+    splitter = "_>fdsplit<_"
 
     # go over each match and add the content to the jsbuffer
     for i ∈ 1:2:length(matches)-1
@@ -69,7 +69,7 @@ function js_prerender_highlight(hs::String)::String
             write(jsbuffer, """console.log("<pre><code class=hljs>$cs</code></pre>");\n""")
         else
             if lang == "html" && is_html_escaped(cs)
-                # corner case, see https://github.com/tlienart/JuDoc.jl/issues/326
+                # corner case, see Franklin.jl/issues/326
                 # highlight will re-escape the string further.
                 cs = html_unescape(cs) |> escape_string
             end
diff --git a/src/converter/lx.jl b/src/converter/lx.jl
index 7cdb8413..9448f70e 100644
--- a/src/converter/lx.jl
+++ b/src/converter/lx.jl
@@ -42,7 +42,7 @@ function resolve_lxcom(lxc::LxCom, lxdefs::Vector{LxDef}; inmath::Bool=false)::S
         end
         partial = ifelse(inmath, mathenv(partial), partial)
     end
-    # reprocess (we don't care about jd_vars=nothing)
+    # reprocess (we don't care about fd_vars=nothing)
     plug, _ = convert_md(partial, lxdefs, isrecursive=true, isconfig=false, has_mddefs=false)
     return plug
 end
diff --git a/src/converter/lx_simple.jl b/src/converter/lx_simple.jl
index 374c724b..7405bc3c 100644
--- a/src/converter/lx_simple.jl
+++ b/src/converter/lx_simple.jl
@@ -1,10 +1,10 @@
-# See src/jd_vars : def_GLOBAL_LXDEFS
+# See src/utils/vars : def_GLOBAL_LXDEFS
 
 """
 $SIGNATURES
 
 Internal function to resolve a `\\output{rpath}` (finds the output of a code block and shows it).
-The `reprocess` argument indicates whether the output should be processed as judoc markdown or
+The `reprocess` argument indicates whether the output should be processed as Franklin-Markdown or
 inserted as is.
 """
 function resolve_lx_output(lxc::LxCom; reprocess::Bool=false)::String
@@ -49,11 +49,12 @@ end
 """
 $SIGNATURES
 
-Internal function to resolve a `\\literate{rpath}` see [`literate_to_judoc`](@ref).
+Internal function to resolve a `\\literate{rpath}` see
+[`literate_to_franklin`](@ref).
 """
 function resolve_lx_literate(lxc::LxCom)::String
     rpath = strip(content(lxc.braces[1]))
-    opath, haschanged = literate_to_judoc(rpath)
+    opath, haschanged = literate_to_franklin(rpath)
     isempty(opath) && return "~~~"*html_err("Literate file matching '$rpath' not found.")*"~~~"
     if !haschanged
         # page has not changed, check if literate is the only source of code
@@ -62,7 +63,7 @@ function resolve_lx_literate(lxc::LxCom)::String
             set_var!(LOCAL_PAGE_VARS, "freezecode", true)
         end
     end
-    if haschanged && JD_ENV[:FULL_PASS]
+    if haschanged && FD_ENV[:FULL_PASS]
         set_var!(LOCAL_PAGE_VARS, "reeval", true)
     end
     # if haschanged=true and not full pass then this will be handled cell by cell
diff --git a/src/converter/md.jl b/src/converter/md.jl
index 72ec2240..4d8875f6 100644
--- a/src/converter/md.jl
+++ b/src/converter/md.jl
@@ -1,8 +1,8 @@
 """
 $(SIGNATURES)
 
-Convert a judoc markdown file read as `mds` into a judoc html string. Returns the html string as
-well as a dictionary of page variables.
+Convert a Franklin-Markdown file read as `mds` into a Franklin HTML string.
+Returns the html string as well as a dictionary of page variables.
 
 **Arguments**
 
@@ -12,7 +12,7 @@ well as a dictionary of page variables.
 **Keyword arguments**
 
 * `isrecursive=false`: a bool indicating whether the call is the parent call or a child call
-* `isinternal=false`:  a bool indicating whether the call stems from `jd2html` in internal mode
+* `isinternal=false`:  a bool indicating whether the call stems from `fd2html` in internal mode
 * `isconfig=false`:    a bool indicating whether the file to convert is the configuration file
 * `has_mddefs=true`:   a bool indicating whether to look for definitions of page variables
 """
@@ -77,9 +77,9 @@ function convert_md(mds::AS, pre_lxdefs::Vector{LxDef}=Vector{LxDef}();
 
     # -----------------------------------------------------------------------------------
     #> 4. Page variable definition (mddefs)
-    jd_vars = nothing
-    has_mddefs && (jd_vars = process_md_defs(blocks, isconfig, lxdefs))
-    isconfig && return "", jd_vars
+    fd_vars = nothing
+    has_mddefs && (fd_vars = process_md_defs(blocks, isconfig, lxdefs))
+    isconfig && return "", fd_vars
 
     # -----------------------------------------------------------------------------------
     #> 5. Process special characters and html entities so that they can be injected
@@ -106,20 +106,20 @@ function convert_md(mds::AS, pre_lxdefs::Vector{LxDef}=Vector{LxDef}();
     hstring   = convert_inter_html(inter_html, mblocks, lxcontext)
 
     # final vars adjustments
-    if !isnothing(jd_vars)
+    if !isnothing(fd_vars)
         #> if there's code, assemble it so that can be shown or loaded in one shot
-        codes = LOCAL_PAGE_VARS["jd_code_scope"].first.codes
+        codes = LOCAL_PAGE_VARS["fd_code_scope"].first.codes
         if !isempty(codes)
-            set_var!(jd_vars, "jd_code", strip(prod(c*"\n" for c in codes)))
+            set_var!(fd_vars, "fd_code", strip(prod(c*"\n" for c in codes)))
         end
         #> if no title is specified, grab the first header if there is one
         if isnothing(LOCAL_PAGE_VARS["title"].first) && !isempty(PAGE_HEADERS)
-            set_var!(jd_vars, "title", first(values(PAGE_HEADERS))[1])
+            set_var!(fd_vars, "title", first(values(PAGE_HEADERS))[1])
         end
     end
 
-    # Return the string + judoc variables
-    return hstring, jd_vars
+    # Return the string + franklin variables
+    return hstring, fd_vars
 end
 
 
@@ -190,7 +190,7 @@ end
 String that is plugged as a placeholder of blocks that need further processing. The spaces allow to
 handle overzealous inclusion of `<p>...</p>` from the base Markdown to HTML conversion.
 """
-const INSERT     = " ##JDINSERT## "
+const INSERT     = " ##FDINSERT## "
 const INSERT_    = strip(INSERT)
 const INSERT_PAT = Regex(INSERT_)
 const INSERT_LEN = length(INSERT_)
@@ -300,8 +300,8 @@ function convert_inter_html(ihtml::AS,
     for (i, m) ∈ enumerate(allmatches)
         # two cases can happen based on whitespaces around an insertion that we
         # want to get rid of, potentially both happen simultaneously.
-        # 1. <p>##JDINSERT##...
-        # 2. ...##JDINSERT##</p>
+        # 1. <p>##FDINSERT##...
+        # 2. ...##FDINSERT##</p>
         # exceptions,
         # - list items introduce <li><p> and </p>\n</li> which shouldn't remove
         # - end of doc introduces </p>(\n?) which should not be removed
@@ -384,6 +384,6 @@ function process_md_defs(blocks::Vector{OCBlock}, isconfig::Bool,
         return nothing
     end
     isempty(assignments) || set_vars!(LOCAL_PAGE_VARS, assignments)
-    jd_vars = merge(GLOBAL_PAGE_VARS, LOCAL_PAGE_VARS)
-    return jd_vars
+    fd_vars = merge(GLOBAL_PAGE_VARS, LOCAL_PAGE_VARS)
+    return fd_vars
 end
diff --git a/src/converter/md_blocks.jl b/src/converter/md_blocks.jl
index 9eb2d6f6..b6afbb6e 100644
--- a/src/converter/md_blocks.jl
+++ b/src/converter/md_blocks.jl
@@ -128,10 +128,10 @@ end
 
 
 """Convenience function to increment the eval' code block counter"""
-increment_code_head() = (LOCAL_PAGE_VARS["jd_code_head"].first[] += 1)
+increment_code_head() = (LOCAL_PAGE_VARS["fd_code_head"].first[] += 1)
 
-"""Convenience function to mark `jd_code_eval` as true (subsequent blocks will be evaled)"""
-toggle_jd_code_eval() = (LOCAL_PAGE_VARS["jd_code_eval"].first[] = true)
+"""Convenience function to mark `fd_code_eval` as true (subsequent blocks will be evaled)"""
+toggle_fd_code_eval() = (LOCAL_PAGE_VARS["fd_code_eval"].first[] = true)
 
 """
 $SIGNATURES
@@ -148,7 +148,7 @@ function eval_and_resolve_code(code::AS, rpath::AS;
     #  3. inserted after cleaning out lines (see resolve_lx_input)
 
     # start by adding it to code scope
-    nopush || push!(LOCAL_PAGE_VARS["jd_code_scope"].first, rpath, code)
+    nopush || push!(LOCAL_PAGE_VARS["fd_code_scope"].first, rpath, code)
 
     # form the path
     path = resolve_assets_rpath(rpath; canonical=true, code=true)
@@ -172,7 +172,7 @@ function eval_and_resolve_code(code::AS, rpath::AS;
     end
 
     write(path, MESSAGE_FILE_GEN_JMD * code)
-    JD_ENV[:SILENT_MODE] || print(rpad("\r→ evaluating code [...] ($(JD_ENV[:CUR_PATH]), $rpath)", 79) * "\r")
+    FD_ENV[:SILENT_MODE] || print(rpad("\r→ evaluating code [...] ($(FD_ENV[:CUR_PATH]), $rpath)", 79) * "\r")
     # - execute the code while redirecting stdout to file
     Logging.disable_logging(Logging.LogLevel(3_000))
     res = nothing
@@ -191,7 +191,7 @@ function eval_and_resolve_code(code::AS, rpath::AS;
         end
     end
     Logging.disable_logging(Logging.Debug)
-    JD_ENV[:SILENT_MODE] || print(rpad("\r→ evaluating code [✓]", 79) * "\r")
+    FD_ENV[:SILENT_MODE] || print(rpad("\r→ evaluating code [✓]", 79) * "\r")
 
     # resolve the code block (highlighting) and return it
     return resolve_lx_input_hlcode(rpath, "julia")
@@ -224,14 +224,14 @@ function convert_code_block(ss::SubString)::String
 
     # extract handles of relevant local page variables
     reeval = LOCAL_PAGE_VARS["reeval"].first         # full page re-eval
-    eval   = LOCAL_PAGE_VARS["jd_code_eval"].first[] # eval toggle from given point
+    eval   = LOCAL_PAGE_VARS["fd_code_eval"].first[] # eval toggle from given point
     freeze = LOCAL_PAGE_VARS["freezecode"].first
-    scope  = LOCAL_PAGE_VARS["jd_code_scope"].first
+    scope  = LOCAL_PAGE_VARS["fd_code_scope"].first
     head   = increment_code_head()
 
     # In the case of forced re-eval, we don't care about the
     # code scope just force-reeval everything sequentially
-    if JD_ENV[:FORCE_REEVAL] || reeval || eval
+    if FD_ENV[:FORCE_REEVAL] || reeval || eval
         length(scope.codes) ≥ head && purgefrom!(scope, head)
         return eval_and_resolve_code(code, rpath)
     end
@@ -241,7 +241,7 @@ function convert_code_block(ss::SubString)::String
     # the case then there will be a check to see if the relevant
     # files exist, if they don't exist the code *will* be eval'ed
     # (see `eval_and_resolve_code`)
-    if JD_ENV[:FULL_PASS] || freeze
+    if FD_ENV[:FULL_PASS] || freeze
         length(scope.codes) ≥ head && purgefrom!(scope, head)
         return eval_and_resolve_code(code, rpath, eval=false)
     end
@@ -251,16 +251,16 @@ function convert_code_block(ss::SubString)::String
     # B. local pass with non-frozen code
 
     # check if the page we're looking at is in scope
-    if JD_ENV[:CUR_PATH] != JD_ENV[:CUR_PATH_WITH_EVAL]
+    if FD_ENV[:CUR_PATH] != FD_ENV[:CUR_PATH_WITH_EVAL]
         # we're necessarily at the first code block of the page.
         # need to re-instantiate a code scope; note that if we
         # are here then necessarily a def_LOCAL_PAGE_VARS was
-        # called, so LOCAL_PAGE_VARS["jd_code_head"] points to 1
+        # called, so LOCAL_PAGE_VARS["fd_code_head"] points to 1
         reset!(scope)
         # keep track that the page is now in scope
-        JD_ENV[:CUR_PATH_WITH_EVAL] = JD_ENV[:CUR_PATH]
+        FD_ENV[:CUR_PATH_WITH_EVAL] = FD_ENV[:CUR_PATH]
         # flag rest of page as to be eval-ed (might be stale)
-        toggle_jd_code_eval()
+        toggle_fd_code_eval()
         # eval and resolve code
         return eval_and_resolve_code(code, rpath)
     end
@@ -281,7 +281,7 @@ function convert_code_block(ss::SubString)::String
             # purge subsequent code blocks as stale
             purgefrom!(scope, head)
             # flag rest of page as to be eval-ed (stale)
-            toggle_jd_code_eval()
+            toggle_fd_code_eval()
         end
     end
     return eval_and_resolve_code(code, rpath)
diff --git a/src/converter/md_utils.jl b/src/converter/md_utils.jl
index 945b9c52..cea3030e 100644
--- a/src/converter/md_utils.jl
+++ b/src/converter/md_utils.jl
@@ -51,11 +51,11 @@ end
 """
 $(SIGNATURES)
 
-The insertion token have whitespaces around them: ` ##JDINSERT## `, this mostly helps but causes
+The insertion token have whitespaces around them: ` ##FDINSERT## `, this mostly helps but causes
 a problem when combined with italic or bold markdown mode since `_blah_` works but not `_ blah _`.
-This function looks for any occurrence of `[\\*_] ##JDINSERT##` or the opposite and removes the
+This function looks for any occurrence of `[\\*_] ##FDINSERT##` or the opposite and removes the
 extraneous whitespace.
 """
 fix_inserts(s::AS)::String =
-    replace(replace(s, r"([\*_]) ##JDINSERT##" => s"\1##JDINSERT##"),
-                       r"##JDINSERT## ([\*_])" => s"##JDINSERT##\1")
+    replace(replace(s, r"([\*_]) ##FDINSERT##" => s"\1##FDINSERT##"),
+                       r"##FDINSERT## ([\*_])" => s"##FDINSERT##\1")
diff --git a/src/integration/literate.jl b/src/integration/literate.jl
index f559c2e4..2448fdb4 100644
--- a/src/integration/literate.jl
+++ b/src/integration/literate.jl
@@ -30,9 +30,9 @@ end
 """
 $SIGNATURES
 
-Take a Literate.jl script and transform it into a JuDoc-markdown file.
+Take a Literate.jl script and transform it into a Franklin-Markdown file.
 """
-function literate_to_judoc(rpath::AS)::Tuple{String,Bool}
+function literate_to_franklin(rpath::AS)::Tuple{String,Bool}
     startswith(rpath, "/") || error("Literate expects a paths starting with '/'")
     # rpath is of the form "/scripts/[path/]tutorial[.jl]"
     # split it so that when recombining it will lead to valid path inc windows
diff --git a/src/manager/file_utils.jl b/src/manager/file_utils.jl
index 54636475..9dff9aad 100644
--- a/src/manager/file_utils.jl
+++ b/src/manager/file_utils.jl
@@ -34,15 +34,15 @@ function write_page(root::String, file::String, head::String,
      # The curpath is the relative path starting after /src/ so for instance:
      # f1/blah/page1.md or index.md etc... this is useful in the code evaluation and management
      # of paths
-    JD_ENV[:CUR_PATH] = fpath[lastindex(PATHS[:src])+length(PATH_SEP)+1:end]
+    FD_ENV[:CUR_PATH] = fpath[lastindex(PATHS[:src])+length(PATH_SEP)+1:end]
 
-    (content, jd_vars) = convert_md(read(fpath, String), collect(values(GLOBAL_LXDEFS)))
+    (content, fd_vars) = convert_md(read(fpath, String), collect(values(GLOBAL_LXDEFS)))
 
     # Check for RSS elements
-    if GLOBAL_PAGE_VARS["generate_rss"].first && JD_ENV[:FULL_PASS] &&
-        !all(e -> e |> first |> isempty, (jd_vars["rss"], jd_vars["rss_description"]))
+    if GLOBAL_PAGE_VARS["generate_rss"].first && FD_ENV[:FULL_PASS] &&
+        !all(e -> e |> first |> isempty, (fd_vars["rss"], fd_vars["rss_description"]))
         # add item to RSSDICT
-        add_rss_item(jd_vars)
+        add_rss_item(fd_vars)
     end
 
     # adding document variables to the dictionary
@@ -50,14 +50,14 @@ function write_page(root::String, file::String, head::String,
     # but it takes negligible time to do this so ¯\_(ツ)_/¯ (and it's less annoying
     # than keeping tabs on which file has already been treated etc).
     s = stat(fpath)
-    set_var!(jd_vars, "jd_ctime", jd_date(unix2datetime(s.ctime)))
-    set_var!(jd_vars, "jd_mtime", jd_date(unix2datetime(s.mtime)))
-    set_var!(jd_vars, "jd_rpath", JD_ENV[:CUR_PATH])
+    set_var!(fd_vars, "fd_ctime", fd_date(unix2datetime(s.ctime)))
+    set_var!(fd_vars, "fd_mtime", fd_date(unix2datetime(s.mtime)))
+    set_var!(fd_vars, "fd_rpath", FD_ENV[:CUR_PATH])
 
-    # 3. process blocks in the html infra elements based on `jd_vars`
+    # 3. process blocks in the html infra elements based on `fd_vars`
     # (e.g.: add the date in the footer)
-    content = convert_html(str(content), jd_vars)
-    head, pg_foot, foot = (e->convert_html(e, jd_vars)).([head, pg_foot, foot])
+    content = convert_html(str(content), fd_vars)
+    head, pg_foot, foot = (e->convert_html(e, fd_vars)).([head, pg_foot, foot])
 
     # 4. construct the page proper & prerender if needed
     pg = build_page(head, content, pg_foot, foot)
@@ -65,7 +65,7 @@ function write_page(root::String, file::String, head::String,
         # KATEX
         pg = js_prerender_katex(pg)
         # HIGHLIGHT
-        if JD_CAN_HIGHLIGHT
+        if FD_CAN_HIGHLIGHT
             pg = js_prerender_highlight(pg)
             # remove script
             pg = replace(pg, r"<script.*?(?:highlight\.pack\.js|initHighlightingOnLoad).*?<\/script>"=>"")
@@ -93,12 +93,12 @@ function process_file(case::Symbol, fpair::Pair{String,String}, args...; kwargs.
     try
         process_file_err(case, fpair, args...; kwargs...)
     catch err
-        JD_ENV[:DEBUG_MODE] && throw(err)
+        FD_ENV[:DEBUG_MODE] && throw(err)
         rp = fpair.first
         rp = rp[end-min(20, length(rp))+1 : end]
         println("\n... encountered an issue processing '$(fpair.second)' in ...$rp.")
-        println("Verify, then start judoc again...\n")
-        JD_ENV[:SUPPRESS_ERR] || @show err
+        println("Verify, then start franklin again...\n")
+        FD_ENV[:SUPPRESS_ERR] || @show err
         return -1
     end
     return 0
@@ -108,9 +108,10 @@ end
 """
 $(SIGNATURES)
 
-Considers a source file which, depending on `case` could be a html file or a file in judoc markdown
-etc, located in a place described by `fpair`, processes it by converting it and adding appropriate
-header and footer and writes it to the appropriate place. It can throw an error which will be
+Considers a source file which, depending on `case` could be a HTML file or a
+file in Franklin-Markdown etc, located in a place described by `fpair`,
+processes it by converting it and adding appropriate header and footer and
+writes it to the appropriate place. It can throw an error which will be
 caught in `process_file(args...)`.
 """
 function process_file_err(case::Symbol, fpair::Pair{String, String}, head::AS="",
@@ -138,7 +139,7 @@ function process_file_err(case::Symbol, fpair::Pair{String, String}, head::AS=""
                 force=true)
         end
     end
-    JD_ENV[:FULL_PASS] || JD_ENV[:SILENT_MODE] || print(rpad("\r→ page updated [✓]", 79)*"\r")
+    FD_ENV[:FULL_PASS] || FD_ENV[:SILENT_MODE] || print(rpad("\r→ page updated [✓]", 79)*"\r")
     return nothing
 end
 
@@ -157,4 +158,4 @@ $(SIGNATURES)
 Convenience function to assemble the html out of its parts.
 """
 build_page(head::String, content::String, pg_foot::String, foot::String)::String =
-    "$head\n<div class=\"jd-content\">\n$content\n$pg_foot\n</div>\n$foot"
+    "$head\n<div class=\"franklin-content\">\n$content\n$pg_foot\n</div>\n$foot"
diff --git a/src/manager/judoc.jl b/src/manager/franklin.jl
similarity index 92%
rename from src/manager/judoc.jl
rename to src/manager/franklin.jl
index a36983c0..4001fc0b 100644
--- a/src/manager/judoc.jl
+++ b/src/manager/franklin.jl
@@ -8,7 +8,7 @@ clear_dicts() = empty!.((GLOBAL_LXDEFS, GLOBAL_PAGE_VARS, LOCAL_PAGE_VARS))
 """
 $(SIGNATURES)
 
-Runs JuDoc in the current directory.
+Runs Franklin in the current directory.
 
 Keyword arguments:
 
@@ -38,15 +38,16 @@ function serve(; clear::Bool=true,
                  cleanup::Bool=true)::Union{Nothing,Int}
     # set the global path
     FOLDER_PATH[]  = pwd()
-    
+
     # silent mode?
-    silent && (JD_ENV[:SILENT_MODE] = true; verb = false)
+    silent && (FD_ENV[:SILENT_MODE] = true; verb = false)
 
     # brief check to see if we're in a folder that looks promising, otherwise stop
     # and tell the user to check (#155)
     if !isdir(joinpath(FOLDER_PATH[], "src"))
-        throw(ArgumentError("The current directory doesn't have a src/ folder. " *
-                            "Please change directory to a valid JuDoc folder."))
+        throw(ArgumentError("The current directory doesn't have a src/ " *
+                            "folder. Please change directory to a valid " *
+                            "Franklin folder."))
     end
 
     # check if a Project.toml file is available, if so activate the folder
@@ -57,17 +58,17 @@ function serve(; clear::Bool=true,
     end
 
     # construct the set of files to watch
-    watched_files = jd_setup(clear=clear)
+    watched_files = fd_setup(clear=clear)
 
     nomess && (verb = false)
 
     # do a first full pass
     nomess || println("→ Initial full pass...")
     start = time()
-    JD_ENV[:FORCE_REEVAL] = eval_all
-    sig = jd_fullpass(watched_files; clear=clear, verb=verb, prerender=prerender,
+    FD_ENV[:FORCE_REEVAL] = eval_all
+    sig = fd_fullpass(watched_files; clear=clear, verb=verb, prerender=prerender,
                       isoptim=isoptim, no_fail_prerender=no_fail_prerender)
-    JD_ENV[:FORCE_REEVAL] = false
+    FD_ENV[:FORCE_REEVAL] = false
     sig < 0 && return sig
     fmsg = rpad("✔ full pass...", 40)
     verb && (println(""); print(fmsg); print_final(fmsg, start); println(""))
@@ -75,7 +76,7 @@ function serve(; clear::Bool=true,
     # start the continuous loop
     if !single
         nomess || println("→ Starting the server...")
-        coreloopfun = (cntr, fw) -> jd_loop(cntr, fw, watched_files; clear=clear, verb=verb)
+        coreloopfun = (cntr, fw) -> fd_loop(cntr, fw, watched_files; clear=clear, verb=verb)
         # start the liveserver in the current directory
         LiveServer.setverbose(verb)
         LiveServer.serve(port=port, coreloopfun=coreloopfun)
@@ -100,7 +101,7 @@ It also sets the paths variables and prepares the output directory.
 
 See also [`serve`](@ref).
 """
-function jd_setup(; clear::Bool=true)::NamedTuple
+function fd_setup(; clear::Bool=true)::NamedTuple
     # . setting up:
     # -- reading and storing the path variables
     # -- setting up the output directory (see `clear`)
@@ -127,7 +128,8 @@ end
 """
 $(SIGNATURES)
 
-A single full pass of judoc looking at all watched files and processing them as appropriate.
+A single full pass of Franklin looking at all watched files and processing them
+as appropriate.
 
 **Keyword arguments**
 
@@ -137,11 +139,11 @@ A single full pass of judoc looking at all watched files and processing them as
 * `isoptim=false`  : whether it's an optimization pass
 * `no_fail_prerender=true`: whether to skip if a prerendering goes wrong in which case don't prerender
 
-See also [`jd_loop`](@ref), [`serve`](@ref) and [`publish`](@ref).
+See also [`fd_loop`](@ref), [`serve`](@ref) and [`publish`](@ref).
 """
-function jd_fullpass(watched_files::NamedTuple; clear::Bool=false,
+function fd_fullpass(watched_files::NamedTuple; clear::Bool=false,
                      verb::Bool=false, prerender::Bool=false, isoptim::Bool=false, no_fail_prerender::Bool=true)::Int
-    JD_ENV[:FULL_PASS] = true
+    FD_ENV[:FULL_PASS] = true
     # initiate page segments
     head    = read(joinpath(PATHS[:src_html], "head.html"), String)
     pg_foot = read(joinpath(PATHS[:src_html], "page_foot.html"), String)
@@ -199,7 +201,7 @@ function jd_fullpass(watched_files::NamedTuple; clear::Bool=false,
     end
     # generate RSS if appropriate
     GLOBAL_PAGE_VARS["generate_rss"].first && rss_generator()
-    JD_ENV[:FULL_PASS] = false
+    FD_ENV[:FULL_PASS] = false
     # return -1 if any page
     return ifelse(s<0, -1, 0)
 end
@@ -216,7 +218,7 @@ updates the `watched_files`.
 * `clear=false`: whether to remove any existing output directory
 * `verb=false`:  whether to display messages
 """
-function jd_loop(cycle_counter::Int, ::LiveServer.FileWatcher, watched_files::NamedTuple;
+function fd_loop(cycle_counter::Int, ::LiveServer.FileWatcher, watched_files::NamedTuple;
                  clear::Bool=false, verb::Bool=false)::Nothing
     # every 30 cycles (3 seconds), scan directory to check for new or deleted files and
     # update dicts accordingly
@@ -245,7 +247,7 @@ function jd_loop(cycle_counter::Int, ::LiveServer.FileWatcher, watched_files::Na
             if haskey(watched_files[:infra], fpair)
                 verb && println("→ full pass...")
                 start = time()
-                jd_fullpass(watched_files; clear=false, verb=false, prerender=false)
+                fd_fullpass(watched_files; clear=false, verb=false, prerender=false)
                 verb && (print_final(rpad("✔ full pass...", 15), start); println(""))
             # if it's a literate file
             elseif haskey(watched_files[:literate], fpair)
diff --git a/src/manager/post_processing.jl b/src/manager/post_processing.jl
index 924b2412..d47e73a6 100644
--- a/src/manager/post_processing.jl
+++ b/src/manager/post_processing.jl
@@ -92,7 +92,7 @@ function verify_links()::Nothing
 end
 
 
-const JD_PY_MIN_NAME = ".__py_tmp_minscript.py"
+const FD_PY_MIN_NAME = ".__py_tmp_minscript.py"
 
 """
 $(SIGNATURES)
@@ -113,15 +113,15 @@ will be larger (especially if you have lots of maths on pages).
 function optimize(; prerender::Bool=true, minify::Bool=true, sig::Bool=false,
                     prepath::String="", no_fail_prerender::Bool=true,
                     suppress_errors::Bool=true, cleanup::Bool=true)::Union{Nothing,Bool}
-    suppress_errors && (JD_ENV[:SUPPRESS_ERR] = true)
+    suppress_errors && (FD_ENV[:SUPPRESS_ERR] = true)
     #
     # Prerendering
     #
-    if prerender && !JD_CAN_PRERENDER
+    if prerender && !FD_CAN_PRERENDER
         @warn "I couldn't find node and so will not be able to pre-render javascript."
         prerender = false
     end
-    if prerender && !JD_CAN_HIGHLIGHT
+    if prerender && !FD_CAN_HIGHLIGHT
         @warn "I couldn't load 'highlight.js' so will not be able to pre-render code blocks. " *
               "You can install it with `npm install highlight.js`."
     end
@@ -146,23 +146,23 @@ function optimize(; prerender::Bool=true, minify::Bool=true, sig::Bool=false,
     # Minification
     #
     if minify && (succ || no_fail_prerender)
-        if JD_CAN_MINIFY
+        if FD_CAN_MINIFY
             start = time()
             mmsg = rpad("→ Minifying *.[html|css] files...", 35)
             print(mmsg)
             # copy the script to the current dir
-            cp(joinpath(dirname(pathof(Franklin)), "scripts", "minify.py"), JD_PY_MIN_NAME; force=true)
+            cp(joinpath(dirname(pathof(Franklin)), "scripts", "minify.py"), FD_PY_MIN_NAME; force=true)
             # run it
-            succ = success(`$([e for e in split(PY)]) $JD_PY_MIN_NAME`)
+            succ = success(`$([e for e in split(PY)]) $FD_PY_MIN_NAME`)
             # remove the script file
-            rm(JD_PY_MIN_NAME)
+            rm(FD_PY_MIN_NAME)
             print_final(mmsg, start)
         else
             @warn "I didn't find css_html_js_minify, you can install it via pip."*
                   "The output will not be minified."
         end
     end
-    JD_ENV[:SUPPRESS_ERR] = false
+    FD_ENV[:SUPPRESS_ERR] = false
     return ifelse(sig, succ, nothing)
 end
 
@@ -180,15 +180,15 @@ It also fixes all links if you specify `prepath` (or if it's set in `config.md`)
 * `minify=true`:         minify output before pushing see [`optimize`](@ref)
 * `nopass=false`:        set this to true if you have already run `optimize` manually.
 * `prepath=""`:          set this to something like "project-name" if it's a project page
-* `message="jd-update"`: add commit message.
+* `message="franklin-update"`: add commit message.
 * `cleanup=true`:        whether to cleanup environment dictionaries (should stay true).
 * `final=nothing`:       a function `()->nothing` to execute last, before doing the git push.
                          It can be used to refresh a Lunr index, generate notebook files with
-                         Literate, etc, ... You might want to compose `jdf_*` functions that are
-                         exported by JuDoc (or imitate those). It can access GLOBAL_PAGE_VARS.
+                         Literate, etc, ... You might want to compose `fdf_*` functions that are
+                         exported by Franklin (or imitate those). It can access GLOBAL_PAGE_VARS.
 """
 function publish(; prerender::Bool=true, minify::Bool=true, nopass::Bool=false,
-                   prepath::String="", message::String="jd-update",
+                   prepath::String="", message::String="franklin-update",
                    cleanup::Bool=true, final::Union{Nothing,Function}=nothing)::Nothing
     succ = true
     if !isempty(prepath) || !nopass
diff --git a/src/manager/rss_generator.jl b/src/manager/rss_generator.jl
index 7fb12e64..270f91c6 100644
--- a/src/manager/rss_generator.jl
+++ b/src/manager/rss_generator.jl
@@ -10,7 +10,7 @@
 # 2. go over all pages
 #  --> is there a rss var?
 #  NO  --> skip
-#  YES --> recuperate the `jd_ctime` and `jd_mtime` and add a RSS channel object
+#  YES --> recuperate the `fd_ctime` and `fd_mtime` and add a RSS channel object
 # 3. save the file
 
 struct RSSItem
@@ -50,23 +50,23 @@ $SIGNATURES
 
 Create an `RSSItem` out of the provided fields defined in the page vars.
 """
-function add_rss_item(jdv::PageVars)::RSSItem
+function add_rss_item(fdv::PageVars)::RSSItem
     link   = url_curpage()
-    title  = jor(jdv, "rss_title", "title")
-    descr  = jor(jdv, "rss", "rss_description")
+    title  = jor(fdv, "rss_title", "title")
+    descr  = jor(fdv, "rss", "rss_description")
 
-    descr = jd2html(descr; internal=true) |> remove_html_ps
+    descr = fd2html(descr; internal=true) |> remove_html_ps
 
-    author    = jdv["rss_author"]    |> first
-    category  = jdv["rss_category"]  |> first
-    comments  = jdv["rss_comments"]  |> first
-    enclosure = jdv["rss_enclosure"] |> first
+    author    = fdv["rss_author"]    |> first
+    category  = fdv["rss_category"]  |> first
+    comments  = fdv["rss_comments"]  |> first
+    enclosure = fdv["rss_enclosure"] |> first
 
-    pubDate = jdv["rss_pubdate"] |> first
+    pubDate = fdv["rss_pubdate"] |> first
     if pubDate == Date(1)
-        pubDate = jdv["date"] |> first
+        pubDate = fdv["date"] |> first
         if !isa(pubDate, Date) || pubDate == Date(1)
-            pubDate = jdv["jd_mtime"] |> first
+            pubDate = fdv["fd_mtime"] |> first
         end
     end
 
@@ -103,7 +103,7 @@ function rss_generator()::Nothing
     end
 
     endswith(rss_link, "/") || (rss_link *= "/")
-    rss_descr = jd2html(rss_descr; internal=true) |> remove_html_ps
+    rss_descr = fd2html(rss_descr; internal=true) |> remove_html_ps
 
     # is there an RSS file already? if so remove it
     rss_path = joinpath(PATHS[:folder], "feed.xml")
diff --git a/src/parser/lx_tokens.jl b/src/parser/lx_tokens.jl
index b4d1f039..b6948d19 100644
--- a/src/parser/lx_tokens.jl
+++ b/src/parser/lx_tokens.jl
@@ -51,7 +51,7 @@ mutable struct LxDef
 end
 # if offset unspecified, start from basically -∞ (configs etc)
 function LxDef(name::String, narg::Int, def::AS)
-    o = JD_ENV[:OFFSET_GLOB_LXDEFS] += 5 # we don't care just fwd a bit
+    o = FD_ENV[:OFFSET_GLOB_LXDEFS] += 5 # we don't care just fwd a bit
     LxDef(name, narg, def, o, o + 3) # we also don't care YOLO
 end
 
diff --git a/src/parser/md_validate.jl b/src/parser/md_validate.jl
index dc33a0fb..20a2c7ff 100644
--- a/src/parser/md_validate.jl
+++ b/src/parser/md_validate.jl
@@ -90,7 +90,7 @@ function validate_and_store_link_defs!(blocks::Vector{OCBlock})::Nothing
                 # we have a [id]: lk add it to PAGE_LINK_DEFS
                 id = subs(parent, nextind(parent, k), ini)
                 # issue #266 in case there's formatting in the link
-                id = jd2html(id, internal=true)
+                id = fd2html(id, internal=true)
                 id = replace(id, r"^<p>"=>"")
                 id = replace(id, r"<\/p>\n$"=>"")
                 lk = β |> content |> strip |> string
diff --git a/src/error_types.jl b/src/utils/errors.jl
similarity index 100%
rename from src/error_types.jl
rename to src/utils/errors.jl
diff --git a/src/misc_html.jl b/src/utils/html.jl
similarity index 98%
rename from src/misc_html.jl
rename to src/utils/html.jl
index 732241b5..74c4049c 100644
--- a/src/misc_html.jl
+++ b/src/utils/html.jl
@@ -91,7 +91,7 @@ Helper function to get the relative url of the current page.
 function url_curpage()
     # go from /pages/.../something.md to /pub/.../something.html note that if
     # on windows then it would be \\ whence the PATH_SEP
-    rp = replace(JD_ENV[:CUR_PATH], Regex("^pages$(escape_string(PATH_SEP))")=>"pub$(PATH_SEP)")
+    rp = replace(FD_ENV[:CUR_PATH], Regex("^pages$(escape_string(PATH_SEP))")=>"pub$(PATH_SEP)")
     rp = unixify(rp)
     rp = splitext(rp)[1] * ".html"
     startswith(rp, "/") || (rp = "/" * rp)
diff --git a/src/misc_utils.jl b/src/utils/misc.jl
similarity index 98%
rename from src/misc_utils.jl
rename to src/utils/misc.jl
index d6b1948d..9b1ce4b5 100644
--- a/src/misc_utils.jl
+++ b/src/utils/misc.jl
@@ -207,8 +207,8 @@ function resolve_assets_rpath(rpath::AS; canonical::Bool=false, code::Bool=false
         # for instance if calling from `src/pages/pg1.md` with `./im1.png` it would refer to
         # /assets/pages/pg1/im1.png
         @assert length(rpath) > 2 "relative path '$rpath' doesn't seem right"
-        canonical || return "/assets/" * unixify(splitext(JD_ENV[:CUR_PATH])[1]) * rpath[3:end]
-        return normpath(joinpath(PATHS[:assets], splitext(JD_ENV[:CUR_PATH])[1], joinrp(rpath[3:end])))
+        canonical || return "/assets/" * unixify(splitext(FD_ENV[:CUR_PATH])[1]) * rpath[3:end]
+        return normpath(joinpath(PATHS[:assets], splitext(FD_ENV[:CUR_PATH])[1], joinrp(rpath[3:end])))
     end
     if code
         # in the code mode we allow a short, this: `julia:ex` is considered
diff --git a/src/jd_paths.jl b/src/utils/paths.jl
similarity index 92%
rename from src/jd_paths.jl
rename to src/utils/paths.jl
index 8afce111..e127f2c6 100644
--- a/src/jd_paths.jl
+++ b/src/utils/paths.jl
@@ -1,7 +1,7 @@
 """
 FOLDER_PATH
 
-Container to keep track of where JuDoc is being run.
+Container to keep track of where Franklin is being run.
 """
 const FOLDER_PATH = Ref{String}()
 
@@ -44,7 +44,7 @@ function set_paths!()::LittleDict{Symbol,String}
 
     # NOTE it is recommended not to change the names of those paths.
     # Particularly for the output dir. If you do, check for example that
-    # functions such as JuDoc.publish point to the right dirs/files.
+    # functions such as Franklin.publish point to the right dirs/files.
 
     PATHS[:folder]    = normpath(FOLDER_PATH[])
     PATHS[:src]       = joinpath(PATHS[:folder],  "src")
diff --git a/src/jd_vars.jl b/src/utils/vars.jl
similarity index 90%
rename from src/jd_vars.jl
rename to src/utils/vars.jl
index a63e8727..55cfc788 100644
--- a/src/jd_vars.jl
+++ b/src/utils/vars.jl
@@ -13,8 +13,8 @@ const GLOBAL_PAGE_VARS = PageVars()
 """
 $(SIGNATURES)
 
-Convenience function to allocate default values of the global site variables. This is called once,
-when JuDoc is started.
+Convenience function to allocate default values of the global site variables.
+This is called once, when Franklin is started.
 """
 @inline function def_GLOBAL_PAGE_VARS!()::Nothing
     empty!(GLOBAL_PAGE_VARS)
@@ -80,8 +80,8 @@ Convenience function to allocate default values of page variables. This is calle
 is processed.
 """
 @inline function def_LOCAL_PAGE_VARS!()::Nothing
-    # NOTE `jd_code` is the only page var we KEEP (stays alive)
-    code_scope = get(LOCAL_PAGE_VARS, "jd_code_scope") do
+    # NOTE `fd_code` is the only page var we KEEP (stays alive)
+    code_scope = get(LOCAL_PAGE_VARS, "fd_code_scope") do
         Pair(CodeScope(),  (CodeScope,)) # the "Any" is lazy but easy
     end
     empty!(LOCAL_PAGE_VARS)
@@ -109,11 +109,11 @@ is processed.
     # in such cases set literate_only to false.
     LOCAL_PAGE_VARS["literate_only"] = Pair(true,       (Bool,))
     #
-    # the jd_* vars should not be assigned externally
-    LOCAL_PAGE_VARS["jd_code_scope"] = code_scope
-    LOCAL_PAGE_VARS["jd_code_head"]  = Pair(Ref(0),     (Ref{Int},))
-    LOCAL_PAGE_VARS["jd_code_eval"]  = Pair(Ref(false), (Ref{Bool},)) # toggle reeval
-    LOCAL_PAGE_VARS["jd_code"]       = Pair("",         (String,))    # just the script
+    # the fd_* vars should not be assigned externally
+    LOCAL_PAGE_VARS["fd_code_scope"] = code_scope
+    LOCAL_PAGE_VARS["fd_code_head"]  = Pair(Ref(0),     (Ref{Int},))
+    LOCAL_PAGE_VARS["fd_code_eval"]  = Pair(Ref(false), (Ref{Bool},)) # toggle reeval
+    LOCAL_PAGE_VARS["fd_code"]       = Pair("",         (String,))    # just the script
 
     # RSS 2.0 item specs:
     # only title, link and description must be defined
@@ -126,7 +126,7 @@ is processed.
     #     comments    -- rss_comments
     #     enclosure   -- rss_enclosure
     # (*) guid        -- [automatically generated from link]
-    #     pubDate     -- rss_pubdate // fallback date // fallback jd_ctime
+    #     pubDate     -- rss_pubdate // fallback date // fallback fd_ctime
     # (*) source      -- [unsupported assumes for now there's only one channel]
     #
     LOCAL_PAGE_VARS["rss"]             = Pair("",      (String,))
@@ -138,10 +138,10 @@ is processed.
     LOCAL_PAGE_VARS["rss_enclosure"]   = Pair("",      (String,))
     LOCAL_PAGE_VARS["rss_pubdate"]     = Pair(Date(1), (Date,))
 
-    # page vars used by judoc, should not be accessed or defined
-    LOCAL_PAGE_VARS["jd_ctime"]  = Pair(Date(1), (Date,))   # time of creation
-    LOCAL_PAGE_VARS["jd_mtime"]  = Pair(Date(1), (Date,))   # time of last modification
-    LOCAL_PAGE_VARS["jd_rpath"]  = Pair("",      (String,)) # local path to file src/[...]/blah.md
+    # page vars used by franklin, should not be accessed or defined
+    LOCAL_PAGE_VARS["fd_ctime"]  = Pair(Date(1), (Date,))   # time of creation
+    LOCAL_PAGE_VARS["fd_mtime"]  = Pair(Date(1), (Date,))   # time of last modification
+    LOCAL_PAGE_VARS["fd_rpath"]  = Pair("",      (String,)) # local path to file src/[...]/blah.md
 
     # If there are GLOBAL vars that are defined, they take precedence
     local_keys = keys(LOCAL_PAGE_VARS)
@@ -261,7 +261,7 @@ the site. See [`resolve_lxcom`](@ref).
 end
 
 #= ==========================================
-Convenience functions related to the jd_vars
+Convenience functions related to the fd_vars
 ============================================= =#
 
 """
@@ -270,7 +270,7 @@ $(SIGNATURES)
 Convenience function taking a `DateTime` object and returning the corresponding formatted string
 with the format contained in `GLOBAL_PAGE_VARS["date_format"]`.
 """
-jd_date(d::DateTime)::AS = Dates.format(d, GLOBAL_PAGE_VARS["date_format"].first)
+fd_date(d::DateTime)::AS = Dates.format(d, GLOBAL_PAGE_VARS["date_format"].first)
 
 
 """
@@ -298,14 +298,14 @@ set_vars, the key function to assign site variables
 """
 $(SIGNATURES)
 
-Given a set of definitions `assignments`, update the variables dictionary `jd_vars`. Keys in
-`assignments` that do not match keys in `jd_vars` are ignored (a warning message is displayed).
+Given a set of definitions `assignments`, update the variables dictionary `fd_vars`. Keys in
+`assignments` that do not match keys in `fd_vars` are ignored (a warning message is displayed).
 The entries in `assignments` are of the form `KEY => STR` where `KEY` is a string key (e.g.:
 "hasmath") and `STR` is an assignment to evaluate (e.g.: "=false").
 """
-function set_vars!(jd_vars::PageVars, assignments::Vector{Pair{String,String}})::PageVars
+function set_vars!(fd_vars::PageVars, assignments::Vector{Pair{String,String}})::PageVars
     # if there's no assignment, cut it short
-    isempty(assignments) && return jd_vars
+    isempty(assignments) && return fd_vars
     # process each assignment in turn
     for (key, assign) ∈ assignments
         # at this point there may still be a comment in the assignment
@@ -323,19 +323,19 @@ function set_vars!(jd_vars::PageVars, assignments::Vector{Pair{String,String}}):
             break
         end
 
-        if haskey(jd_vars, key)
+        if haskey(fd_vars, key)
             # if the retrieved value has the right type, assign it to the corresponding key
             type_tmp  = typeof(tmp)
-            acc_types = jd_vars[key].second
+            acc_types = fd_vars[key].second
             if check_type(type_tmp, acc_types)
-                jd_vars[key] = Pair(tmp, acc_types)
+                fd_vars[key] = Pair(tmp, acc_types)
             else
                 @warn "Doc var '$key' (type(s): $acc_types) can't be set to value '$tmp' (type: $type_tmp). Assignment ignored."
             end
         else
             # there is no key, so directly assign, the type is not checked
-            jd_vars[key] = Pair(tmp, (typeof(tmp), ))
+            fd_vars[key] = Pair(tmp, (typeof(tmp), ))
         end
     end
-    return jd_vars
+    return fd_vars
 end


Test patch:
diff --git a/test/converter/eval.jl b/test/converter/eval.jl
index 0a6f7cf1..8de59993 100644
--- a/test/converter/eval.jl
+++ b/test/converter/eval.jl
@@ -1,4 +1,4 @@
-J.JD_ENV[:CUR_PATH] = "index.md"
+J.FD_ENV[:CUR_PATH] = "index.md"
 
 @testset "Evalcode" begin
     # see `converter/md_blocks:convert_code_block`
@@ -99,7 +99,7 @@ end
 
     # ------------
 
-    J.JD_ENV[:CUR_PATH] = "pages/pg1.md"
+    J.FD_ENV[:CUR_PATH] = "pages/pg1.md"
 
     h = raw"""
         Simple code:
@@ -145,7 +145,7 @@ end
 end
 
 @testset "Eval (img)" begin
-    J.JD_ENV[:CUR_PATH] = "index.html"
+    J.FD_ENV[:CUR_PATH] = "index.html"
     h = raw"""
         Simple code:
         ```julia:tv2
@@ -221,7 +221,7 @@ end
         a *= 2
         ```
         \show{ex}
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test isapproxstr(h, """
         <pre><code class="language-julia">a = 5
         a *= 2</code></pre>
@@ -238,7 +238,7 @@ end
         a *= 2
         ```
         \show{ex}
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test isapproxstr(h, """
         <pre><code class="language-julia">a = 5
         println("hello")
diff --git a/test/converter/html.jl b/test/converter/html.jl
index f706e3d7..8801e30c 100644
--- a/test/converter/html.jl
+++ b/test/converter/html.jl
@@ -85,22 +85,22 @@ end
         "b1" => false => (Bool,),
         "b2" => true => (Bool,))
 
-    jdc = x->J.convert_html(x, allvars)
+    fdc = x->J.convert_html(x, allvars)
 
     # flag b1 is false
-    @test "{{if b1}} blah {{ else }} blih {{ end }}" |> jdc == " blih " # else
-    @test "{{if b1}} {{ else }} blih {{ end }}" |> jdc == " blih "      # else
+    @test "{{if b1}} blah {{ else }} blih {{ end }}" |> fdc == " blih " # else
+    @test "{{if b1}} {{ else }} blih {{ end }}" |> fdc == " blih "      # else
 
     # flag b2 is true
-    @test "{{if b2}} blah {{ else }} blih {{ end }}" |> jdc == " blah " # if
-    @test "{{if b2}} blah {{ else }} {{ end }}" |> jdc == " blah "      # if
-    @test "{{if b2}} blah {{ end }}" |> jdc == " blah "                 # if
-
-    @test "{{if b1}} blah {{ else }} {{ end }}" |> jdc == " " # else, empty
-    @test "{{if b1}} {{ else }} {{ end }}" |> jdc == " "      # else, empty
-    @test "{{if b1}} blah {{ end }}" |> jdc == ""            # else, empty
-    @test "{{if b2}} {{ else }} {{ end }}" |> jdc == " "      # if, empty
-    @test "{{if b2}} {{ else }} blih {{ end }}" |> jdc == " " # if, empty
+    @test "{{if b2}} blah {{ else }} blih {{ end }}" |> fdc == " blah " # if
+    @test "{{if b2}} blah {{ else }} {{ end }}" |> fdc == " blah "      # if
+    @test "{{if b2}} blah {{ end }}" |> fdc == " blah "                 # if
+
+    @test "{{if b1}} blah {{ else }} {{ end }}" |> fdc == " " # else, empty
+    @test "{{if b1}} {{ else }} {{ end }}" |> fdc == " "      # else, empty
+    @test "{{if b1}} blah {{ end }}" |> fdc == ""            # else, empty
+    @test "{{if b2}} {{ else }} {{ end }}" |> fdc == " "      # if, empty
+    @test "{{if b2}} {{ else }} blih {{ end }}" |> fdc == " " # if, empty
 end
 
 @testset "Cond ispage" begin
@@ -111,14 +111,14 @@ end
         {{isnotpage blah.html ya/xx}} blih {{end}} done.
         """
 
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
     @test J.convert_html(hs, allvars) == "Some text then  blah  but\n blih  done.\n"
 
-    J.JD_ENV[:CUR_PATH] = "blah/blih.md"
+    J.FD_ENV[:CUR_PATH] = "blah/blih.md"
     hs = raw"""
         A then {{ispage blah/*}}yes{{end}} but not {{isnotpage blih/*}}no{{end}} E.
         """
     @test J.convert_html(hs, allvars) == "A then yes but not no E.\n"
 
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
 end
diff --git a/test/converter/hyperref.jl b/test/converter/hyperref.jl
index 30e7afde..de333bc6 100644
--- a/test/converter/hyperref.jl
+++ b/test/converter/hyperref.jl
@@ -1,5 +1,5 @@
 @testset "Hyperref" begin
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
     st = raw"""
        Some string
        $$ x = x \label{eq 1}$$
@@ -51,7 +51,7 @@
 end
 
 @testset "Href-space" begin
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
     st = raw"""
        A
        $$ x = x \label{eq 1}$$
diff --git a/test/converter/lx_input.jl b/test/converter/lx_input.jl
index 47b4a715..1354f62a 100644
--- a/test/converter/lx_input.jl
+++ b/test/converter/lx_input.jl
@@ -2,7 +2,7 @@
     #
     # check_input_fname
     #
-    J.JD_ENV[:CUR_PATH] = "index.html"
+    J.FD_ENV[:CUR_PATH] = "index.html"
     script1 = joinpath(J.PATHS[:assets], "index", "code", "script1.jl")
     write(script1, "1+1")
     fp, d, fn = J.check_input_rpath("script1.jl", code=true)
diff --git a/test/converter/markdown.jl b/test/converter/markdown.jl
index 79f3439b..78d588c5 100644
--- a/test/converter/markdown.jl
+++ b/test/converter/markdown.jl
@@ -21,9 +21,9 @@
     blocks2insert, = steps[:blocks2insert]
 
     inter_md, mblocks = J.form_inter_md(st, blocks2insert, lxdefs)
-    @test inter_md == "\n\nA list\n*  ##JDINSERT##  and  ##JDINSERT## \n*  ##JDINSERT##  is a function\n* a last element\n"
+    @test inter_md == "\n\nA list\n*  ##FDINSERT##  and  ##FDINSERT## \n*  ##FDINSERT##  is a function\n* a last element\n"
     inter_html = J.md2html(inter_md)
-    @test inter_html == "<p>A list</p>\n<ul>\n<li><p>##JDINSERT##  and  ##JDINSERT## </p>\n</li>\n<li><p>##JDINSERT##  is a function</p>\n</li>\n<li><p>a last element</p>\n</li>\n</ul>\n"
+    @test inter_html == "<p>A list</p>\n<ul>\n<li><p>##FDINSERT##  and  ##FDINSERT## </p>\n</li>\n<li><p>##FDINSERT##  is a function</p>\n</li>\n<li><p>a last element</p>\n</li>\n</ul>\n"
 end
 
 
@@ -42,7 +42,7 @@ end
         """
 
     inter_md, = explore_md_steps(st)[:inter_md]
-    @test inter_md == " ##JDINSERT## \nfinally ⊙⊙𝛴⊙ and\n ##JDINSERT## \ndone\n"
+    @test inter_md == " ##FDINSERT## \nfinally ⊙⊙𝛴⊙ and\n ##FDINSERT## \ndone\n"
 end
 
 
@@ -56,7 +56,7 @@ end
     lxdefs, tokens, braces, blocks, lxcoms = steps[:latex]
     blocks2insert, = steps[:blocks2insert]
     inter_md, mblocks = steps[:inter_md]
-    @test inter_md == "ab ##JDINSERT## \n ##JDINSERT## \n"
+    @test inter_md == "ab ##FDINSERT## \n ##FDINSERT## \n"
 
     inter_html, = steps[:inter_html]
     lxcontext = J.LxContext(lxcoms, lxdefs, braces)
@@ -91,12 +91,12 @@ end
     inter_html, = steps[:inter_html]
 
     @test isapproxstr(inter_md, """
-                                text A1 text A2  ##JDINSERT##  and
-                                ##JDINSERT##
-                                text C1  ##JDINSERT##  text C2
-                                then  ##JDINSERT## .""")
+                                text A1 text A2  ##FDINSERT##  and
+                                ##FDINSERT##
+                                text C1  ##FDINSERT##  text C2
+                                then  ##FDINSERT## .""")
 
-    @test isapproxstr(inter_html, """<p>text A1 text A2  ##JDINSERT##  and  ##JDINSERT##   text C1  ##JDINSERT##  text C2  then  ##JDINSERT## .</p>""")
+    @test isapproxstr(inter_html, """<p>text A1 text A2  ##FDINSERT##  and  ##FDINSERT##   text C1  ##FDINSERT##  text C2  then  ##FDINSERT## .</p>""")
 
     lxcontext = J.LxContext(lxcoms, lxdefs, braces)
     hstring = J.convert_inter_html(inter_html, blocks2insert, lxcontext)
@@ -109,7 +109,7 @@ end
 
 
 @testset "headers" begin
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
     h = """
         # Title
         and then
diff --git a/test/converter/markdown2.jl b/test/converter/markdown2.jl
index 01a2153f..e926509a 100644
--- a/test/converter/markdown2.jl
+++ b/test/converter/markdown2.jl
@@ -8,41 +8,41 @@ end
 @testset "issue163" begin
     st = raw"""A _B `C` D_ E"""
     imd, ih = inter(st)
-    @test imd == "A _B  ##JDINSERT##  D_ E"
-    @test ih == "<p>A <em>B  ##JDINSERT##  D</em> E</p>\n"
+    @test imd == "A _B  ##FDINSERT##  D_ E"
+    @test ih == "<p>A <em>B  ##FDINSERT##  D</em> E</p>\n"
 
     st = raw"""A _`B` C D_ E"""
     imd, ih = inter(st)
-    @test imd == "A _ ##JDINSERT##  C D_ E"
-    @test ih == "<p>A <em>##JDINSERT##  C D</em> E</p>\n"
+    @test imd == "A _ ##FDINSERT##  C D_ E"
+    @test ih == "<p>A <em>##FDINSERT##  C D</em> E</p>\n"
 
     st = raw"""A _B C `D`_ E"""
     imd, ih = inter(st)
-    @test imd == "A _B C  ##JDINSERT## _ E"
-    @test ih == "<p>A <em>B C  ##JDINSERT##</em> E</p>\n"
+    @test imd == "A _B C  ##FDINSERT## _ E"
+    @test ih == "<p>A <em>B C  ##FDINSERT##</em> E</p>\n"
 
     st = raw"""A _`B` C `D`_ E"""
     imd, ih = inter(st)
-    @test imd == "A _ ##JDINSERT##  C  ##JDINSERT## _ E"
-    @test ih == "<p>A <em>##JDINSERT##  C  ##JDINSERT##</em> E</p>\n"
+    @test imd == "A _ ##FDINSERT##  C  ##FDINSERT## _ E"
+    @test ih == "<p>A <em>##FDINSERT##  C  ##FDINSERT##</em> E</p>\n"
 end
 
 
 @testset "TOC"  begin
-    J.JD_ENV[:CUR_PATH] = "pages/ff/aa.md"
+    J.FD_ENV[:CUR_PATH] = "pages/ff/aa.md"
     h = raw"""
         \toc
-        ## Hello `jd`
+        ## Hello `fd`
         #### weirdly nested
         ### Goodbye!
         ## Done
         done.
         """ |> seval
     @test isapproxstr(h, raw"""
-        <div class="jd-toc">
+        <div class="franklin-toc">
           <ol>
             <li>
-              <a href="/pub/ff/aa.html#hello_jd">Hello <code>jd</code></a>
+              <a href="/pub/ff/aa.html#hello_fd">Hello <code>fd</code></a>
               <ol>
                 <li><ol><li><a href="/pub/ff/aa.html#weirdly_nested">weirdly nested</a></li></ol></li>
                 <li><a href="/pub/ff/aa.html#goodbye">Goodbye&#33;</a></li>
@@ -51,7 +51,7 @@ end
             <li><a href="/pub/ff/aa.html#done">Done</a></li>
           </ol>
         </div>
-        <h2 id="hello_jd"><a href="/pub/ff/aa.html#hello_jd">Hello <code>jd</code></a></h2>
+        <h2 id="hello_fd"><a href="/pub/ff/aa.html#hello_fd">Hello <code>fd</code></a></h2>
         <h4 id="weirdly_nested"><a href="/pub/ff/aa.html#weirdly_nested">weirdly nested</a></h4>
         <h3 id="goodbye"><a href="/pub/ff/aa.html#goodbye">Goodbye&#33;</a></h3>
         <h2 id="done"><a href="/pub/ff/aa.html#done">Done</a></h2>done.
@@ -59,7 +59,7 @@ end
 end
 
 @testset "TOC"  begin
-    J.JD_ENV[:CUR_PATH] = "pages/ff/aa.md"
+    J.FD_ENV[:CUR_PATH] = "pages/ff/aa.md"
     s = raw"""
         @def mintoclevel = 2
         @def maxtoclevel = 3
@@ -73,7 +73,7 @@ end
         done.
         """ |> seval
     @test isapproxstr(s, raw"""
-        <div class="jd-toc">
+        <div class="franklin-toc">
             <ol>
                 <li><a href="/pub/ff/aa.html#b">B</a>
                     <ol>
diff --git a/test/converter/markdown3.jl b/test/converter/markdown3.jl
index 36cdb999..b6661a1c 100644
--- a/test/converter/markdown3.jl
+++ b/test/converter/markdown3.jl
@@ -32,7 +32,7 @@
 
     inter_html, = steps[:inter_html]
 
-    @test isapproxstr(inter_html, "<p>Hello  ##JDINSERT##  blah  ##JDINSERT##  end and  ##JDINSERT##  end and  ##JDINSERT##  done</p>")
+    @test isapproxstr(inter_html, "<p>Hello  ##FDINSERT##  blah  ##FDINSERT##  end and  ##FDINSERT##  end and  ##FDINSERT##  done</p>")
 
     @test isapproxstr(st |> seval, raw"""
                 <p>Hello &#92; blah &#92; end
@@ -325,7 +325,7 @@ end
 @testset "Issue 266" begin
     s = """Blah [`hello`] and later
        [`hello`]: https://github.com/cormullion/
-       """ |> jd2html_td
+       """ |> fd2html_td
     @test isapproxstr(s, """
         <p>Blah
         <a href="https://github.com/cormullion/"><code>hello</code></a>
@@ -341,7 +341,7 @@ end
        ```
        end
        """
-    @test isapproxstr(s |> jd2html_td, """
+    @test isapproxstr(s |> fd2html_td, """
         <p>blah
         <pre><code class=\"language-TOML\">socrates</code></pre>
     end</p>""")
@@ -352,7 +352,7 @@ end
        ```
        end
        """
-    @test isapproxstr(s |> jd2html_td, """
+    @test isapproxstr(s |> fd2html_td, """
         <p>blah
         <pre><code class=\"language-julia-repl\">socrates</code></pre>
     end</p>""")
diff --git a/test/converter/markdown4.jl b/test/converter/markdown4.jl
index 7836b737..0def50cc 100644
--- a/test/converter/markdown4.jl
+++ b/test/converter/markdown4.jl
@@ -2,7 +2,7 @@
     s = raw"""
     \newcommand{\hello}{hello}
     A\hello B
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, "<p>Ahello B</p>")
     s = raw"""
     \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}}
@@ -10,7 +10,7 @@
     \eqa{
         D
     }E
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, raw"""
             <p>
             A\[\begin{array}{c} B\end{array}\]C
@@ -22,7 +22,7 @@
     \eqa{A\\
         D
     }E
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, raw"""
         \[\begin{array}{c} A\\
         D\end{array}\]E
@@ -31,7 +31,7 @@
     @def indented_code = false
     \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}}
     \eqa{A\\
-        D}E""" |> jd2html_td
+        D}E""" |> fd2html_td
     @test isapproxstr(s, raw"""
         \[\begin{array}{c} A\\
         D\end{array}\]E
@@ -42,7 +42,7 @@ end
     s = raw"""
     \newcommand{\esp}{\quad\!\!}
     $$A\esp=B$$
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, raw"\[A\quad\!\!=B\]")
 end
 
@@ -55,7 +55,7 @@ end
             E
     D
     ```
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, """<p>A <pre><code class="language-julia">C\n    B\n        E\nD</code></pre></p>\n""")
 end
 
@@ -66,7 +66,7 @@ end
     <div class="foo">Blah</div>
     ```
     End
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, """
         <p>
         Blah <pre><code class="language-html">&lt;div class&#61;&quot;foo&quot;&gt;Blah&lt;/div&gt;</code></pre>
diff --git a/test/coverage/extras1.jl b/test/coverage/extras1.jl
index 16277682..cb0fd6ad 100644
--- a/test/coverage/extras1.jl
+++ b/test/coverage/extras1.jl
@@ -19,16 +19,16 @@ end
     s = """
         @def blah
         """
-    @test (@test_logs (:warn, "Found delimiters for an @def environment but it didn't have the right @def var = ... format. Verify (ignoring for now).") (s |> jd2html_td)) == ""
+    @test (@test_logs (:warn, "Found delimiters for an @def environment but it didn't have the right @def var = ... format. Verify (ignoring for now).") (s |> fd2html_td)) == ""
 
     s = """
         Blah
         [^1]: hello
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test isapproxstr(s, "<p>Blah </p>")
 end
 
-@testset "Judoc" begin
+@testset "Franklin" begin
     cd(td); mkpath("foo"); cd("foo");
     @test_throws ArgumentError serve(single=true)
     cd(td)
@@ -49,23 +49,23 @@ end
     s = raw"""
         \newcommand{hello}{hello}
         """
-    @test_throws J.LxDefError (s |> jd2html)
+    @test_throws J.LxDefError (s |> fd2html)
     s = raw"""
         \foo
         """
-    @test_throws J.LxComError (s |> jd2html)
+    @test_throws J.LxComError (s |> fd2html)
     s = raw"""
         \newcommand{\foo}[2]{hello #1 #2}
         \foo{a} {}
         """
-    @test_throws J.LxComError (s |> jd2html)
+    @test_throws J.LxComError (s |> fd2html)
 end
 
 @testset "ocblocks" begin
     s = raw"""
         @@foo
         """
-    @test_throws J.OCBlockError (s |> jd2html)
+    @test_throws J.OCBlockError (s |> fd2html)
 end
 
 @testset "tofrom" begin
diff --git a/test/jd_paths_vars.jl b/test/frank_paths_vars.jl
similarity index 90%
rename from test/jd_paths_vars.jl
rename to test/frank_paths_vars.jl
index b1241f32..60e29509 100644
--- a/test/jd_paths_vars.jl
+++ b/test/frank_paths_vars.jl
@@ -2,8 +2,8 @@ const td = mktempdir()
 flush_td() = (isdir(td) && rm(td; recursive=true); mkdir(td))
 J.FOLDER_PATH[] = td
 
-jd2html_td(e)  = jd2html(e; dir=td)
-jd2html_tdv(e) = J.jd2html_v(e; dir=td)
+fd2html_td(e)  = fd2html(e; dir=td)
+fd2html_tdv(e) = J.fd2html_v(e; dir=td)
 
 J.def_GLOBAL_PAGE_VARS!()
 J.def_GLOBAL_LXDEFS!()
@@ -58,7 +58,7 @@ end
         @def hasmath = false
         etc
         """
-    (m, jdv) = J.convert_md(st)
-    @test jdv["title"].first == "blah"
-    @test jdv["hasmath"].first == false
+    (m, fdv) = J.convert_md(st)
+    @test fdv["title"].first == "blah"
+    @test fdv["hasmath"].first == false
 end
diff --git a/test/global/cases1.jl b/test/global/cases1.jl
index 44ec727a..a8887b5e 100644
--- a/test/global/cases1.jl
+++ b/test/global/cases1.jl
@@ -35,7 +35,7 @@ end
         \com{A}
         """
     steps = st |> explore_md_steps
-    @test steps[:inter_md].inter_md == "\n ##JDINSERT## \n\n ##JDINSERT## \n"
+    @test steps[:inter_md].inter_md == "\n ##FDINSERT## \n\n ##FDINSERT## \n"
     @test st |> conv == "⭒A⭒\n◲A◲"
 end
 
diff --git a/test/global/cases2.jl b/test/global/cases2.jl
index 1b6348c6..56095a3d 100644
--- a/test/global/cases2.jl
+++ b/test/global/cases2.jl
@@ -61,7 +61,7 @@ end
 
 
 @testset "Table" begin
-    J.JD_ENV[:CUR_PATH] = "pages/pg1.html"
+    J.FD_ENV[:CUR_PATH] = "pages/pg1.html"
     st = """
         A
 
@@ -111,6 +111,6 @@ end
     # AAA
     etc
     ~~~{{fill title}}~~~
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(s, raw"""<h1 id="aaa"><a href="/index.html#aaa">AAA</a></h1>  etc AAA""")
 end
diff --git a/test/global/eval.jl b/test/global/eval.jl
index 70ada78b..1258ec56 100644
--- a/test/global/eval.jl
+++ b/test/global/eval.jl
@@ -21,7 +21,7 @@
 
     # FIRST PASS --> EVAL
 
-    h = foo |> jd2html_td
+    h = foo |> fd2html_td
 
     @test isapproxstr(h, """
                 <pre><code class="language-julia">println(randn())</code></pre> <pre><code class=\"plaintext\">$a</code></pre>
@@ -31,7 +31,7 @@
 
     foo *= "etc"
 
-    h = foo |> jd2html_td
+    h = foo |> fd2html_td
 
     @test isapproxstr(h, """
                 <pre><code class="language-julia">println(randn())</code></pre> <pre><code class=\"plaintext\">$a</code></pre> etc
@@ -50,7 +50,7 @@
         \output{ex3}
         """
 
-    h = foo |> jd2html_td
+    h = foo |> fd2html_td
 
     @test isapproxstr(h, """
                 <pre><code class="language-julia">println(randn())</code></pre> <pre><code class=\"plaintext\">$a</code></pre> etc
@@ -77,7 +77,7 @@
         \output{ex3}
         """
 
-    h = foo |> jd2html_td
+    h = foo |> fd2html_td
 
     @test isapproxstr(h, """
                 <pre><code class="language-julia">println(randn())</code></pre> <pre><code class=\"plaintext\">$a</code></pre>
@@ -106,7 +106,7 @@
         \output{ex3}
         """
 
-    h = foo |> jd2html_td
+    h = foo |> fd2html_td
 
     @test isapproxstr(h, """
                 <pre><code class="language-julia">println(randn())</code></pre> <pre><code class=\"plaintext\">$a</code></pre>
@@ -132,7 +132,7 @@ end
         println(a)
         ```
         \output{ex2}
-        """ |> jd2html_tdv
+        """ |> fd2html_tdv
 
     @test isapproxstr(h, """
             <pre><code class="language-julia">a = 5
@@ -143,7 +143,7 @@ end
             <pre><code class=\"plaintext\">8</code></pre>
             """)
 
-    @test isapproxstr(J.str(vars["jd_code"].first), """
+    @test isapproxstr(J.str(vars["fd_code"].first), """
         a = 5
         println(a)
 
@@ -168,7 +168,7 @@ end
         println(a)
         ```
         \output{ex2}
-        """ |> jd2html_tdv
+        """ |> fd2html_tdv
 
     @test isapproxstr(h, """
             <pre><code class="language-julia">a = 5
@@ -181,7 +181,7 @@ end
             println(a)</code></pre>
             <pre><code class=\"plaintext\">9</code></pre>
             """)
-    @test isapproxstr(J.str(vars["jd_code"].first), """
+    @test isapproxstr(J.str(vars["fd_code"].first), """
         a = 5
         println(a)
 
diff --git a/test/global/html_esc.jl b/test/global/html_esc.jl
index 4f2b188b..9a6159ac 100644
--- a/test/global/html_esc.jl
+++ b/test/global/html_esc.jl
@@ -1,4 +1,4 @@
-# See https://github.com/tlienart/JuDoc.jl/issues/326
+# See https://github.com/tlienart/Franklin.jl/issues/326
 
 @testset "Issue 326" begin
     h1 = "<div class=\"hello\">Blah</div>"
diff --git a/test/global/postprocess.jl b/test/global/postprocess.jl
index 1b184462..a82adc2b 100644
--- a/test/global/postprocess.jl
+++ b/test/global/postprocess.jl
@@ -11,7 +11,7 @@
                  )
               )
     # ---------------
-    if Franklin.JD_CAN_MINIFY
+    if Franklin.FD_CAN_MINIFY
         presize1 = stat(joinpath("css", "basic.css")).size
         presize2 = stat("index.html").size
         optimize(prerender=false)
@@ -38,13 +38,13 @@
     @test occursin("=\"/prependme/libs/katex/katex.min.css", index)
 end
 
-if J.JD_CAN_PRERENDER; @testset "prerender" begin
+if J.FD_CAN_PRERENDER; @testset "prerender" begin
     @testset "katex" begin
         hs = raw"""
         <!doctype html>
         <html lang=en>
         <meta charset=UTF-8>
-        <div class=jd-content>
+        <div class=franklin-content>
         <p>range is \(10\sqrt{3}\)–\(20\sqrt{2}\) <!-- non-ascii en dash --></p>
         <p>Consider an invertible matrix \(M\) made of blocks \(A\), \(B\), \(C\) and \(D\) with</p>
         \[ M \quad\!\! =\quad\!\! \begin{pmatrix} A & B \\ C & D \end{pmatrix} \]
@@ -60,12 +60,12 @@ if J.JD_CAN_PRERENDER; @testset "prerender" begin
         @test occursin("""<span class=\"katex-display\"><span class=\"katex\"><span class=\"katex-mathml\"><math xmlns=\"http://www.w3.org/1998/Math/MathML\"><semantics><mrow><mi>M</mi>""", jskx)
     end
 
-    if J.JD_CAN_HIGHLIGHT; @testset "highlight" begin
+    if J.FD_CAN_HIGHLIGHT; @testset "highlight" begin
         hs = raw"""
         <!doctype html>
         <html lang=en>
         <meta charset=UTF-8>
-        <div class=jd-content>
+        <div class=franklin-content>
         <h1>Title</h1>
         <p>Blah</p>
         <pre><code class=language-julia >using Test
diff --git a/test/integration/literate.jl b/test/integration/literate.jl
index b734c46a..a912f59e 100644
--- a/test/integration/literate.jl
+++ b/test/integration/literate.jl
@@ -39,7 +39,7 @@ end
 end
 
 @testset "Literate-b" begin
-    # Literate to JuDoc
+    # Literate to Franklin
     s = raw"""
         # # Rational numbers
         #
@@ -56,7 +56,7 @@ end
         """
     path = joinpath(scripts, "tutorial.jl")
     write(path, s)
-    opath, = J.literate_to_judoc("/literate-scripts/tutorial")
+    opath, = J.literate_to_franklin("/literate-scripts/tutorial")
     @test endswith(opath, joinpath(J.PATHS[:assets], "literate", "tutorial.md"))
     out = read(opath, String)
     @test out == """
@@ -87,7 +87,7 @@ end
         @def reeval = true
 
         \literate{/literate-scripts/tutorial.jl}
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test isapproxstr(h, """
         <h1 id="rational_numbers"><a href="/index.html#rational_numbers">Rational numbers</a></h1>
         <p>In julia rational numbers can be constructed with the <code>//</code> operator. Lets define two rational numbers, <code>x</code> and <code>y</code>:</p>
@@ -105,9 +105,9 @@ end
     s = raw"""
         \literate{foo}
         """
-    @test_throws ErrorException (s |> jd2html_td)
+    @test_throws ErrorException (s |> fd2html_td)
     s = raw"""
         \literate{/foo}
         """
-    @test @test_logs (:warn, "File not found when trying to convert a literate file ($(joinpath(J.PATHS[:folder], "foo.jl"))).") (s |> jd2html_td) == """<p><span style="color:red;">// Literate file matching '/foo' not found. //</span></p></p>\n"""
+    @test @test_logs (:warn, "File not found when trying to convert a literate file ($(joinpath(J.PATHS[:folder], "foo.jl"))).") (s |> fd2html_td) == """<p><span style="color:red;">// Literate file matching '/foo' not found. //</span></p></p>\n"""
 end
diff --git a/test/manager/config.jl b/test/manager/config.jl
index 3c8d815b..4337ab0a 100644
--- a/test/manager/config.jl
+++ b/test/manager/config.jl
@@ -35,7 +35,7 @@ foofig(p, s) = (write(joinpath(p, "src", "config.md"), s); J.process_config())
           J.GLOBAL_LXDEFS["\\hellob"].from < J.GLOBAL_LXDEFS["\\hellob"].to <
           J.GLOBAL_LXDEFS["\\helloc"].from < J.GLOBAL_LXDEFS["\\helloc"].to
 
-    @test jd2html(raw"""\helloc"""; dir=p, internal=true) == "goodbye"
+    @test fd2html(raw"""\helloc"""; dir=p, internal=true) == "goodbye"
 
     # ================================
     # go back and cleanup
diff --git a/test/manager/rss.jl b/test/manager/rss.jl
index 36276051..dac3aa34 100644
--- a/test/manager/rss.jl
+++ b/test/manager/rss.jl
@@ -14,24 +14,24 @@ end
 
 @testset "RSSbasics" begin
     empty!(J.RSS_DICT)
-    J.JD_ENV[:CUR_PATH] = "hey/ho.md"
+    J.FD_ENV[:CUR_PATH] = "hey/ho.md"
     J.set_var!(J.GLOBAL_PAGE_VARS, "website_title", "Website title")
     J.set_var!(J.GLOBAL_PAGE_VARS, "website_descr", "Website descr")
-    J.set_var!(J.GLOBAL_PAGE_VARS, "website_url", "https://github.com/tlienart/JuDoc.jl/")
-    jdv = merge(J.GLOBAL_PAGE_VARS, copy(J.LOCAL_PAGE_VARS))
-    J.set_var!(jdv, "rss_title", "title")
-    J.set_var!(jdv, "rss", "A **description** done.")
-    J.set_var!(jdv, "rss_author", "chuck@norris.com")
+    J.set_var!(J.GLOBAL_PAGE_VARS, "website_url", "https://github.com/tlienart/Franklin.jl/")
+    fdv = merge(J.GLOBAL_PAGE_VARS, copy(J.LOCAL_PAGE_VARS))
+    J.set_var!(fdv, "rss_title", "title")
+    J.set_var!(fdv, "rss", "A **description** done.")
+    J.set_var!(fdv, "rss_author", "chuck@norris.com")
 
-    item = J.add_rss_item(jdv)
+    item = J.add_rss_item(fdv)
     @test item.title == "title"
     @test item.description == "A <strong>description</strong> done.\n"
     @test item.author == "chuck@norris.com"
     # unchanged bc all three fallbacks lead to Data(1)
     @test item.pubDate == Date(1)
 
-    J.set_var!(jdv, "rss_title", "")
-    @test @test_logs (:warn, "Found an RSS description but no title for page /hey/ho.html.") J.add_rss_item(jdv).title == ""
+    J.set_var!(fdv, "rss_title", "")
+    @test @test_logs (:warn, "Found an RSS description but no title for page /hey/ho.html.") J.add_rss_item(fdv).title == ""
 
     @test J.RSS_DICT["/hey/ho.html"].description == item.description
 
diff --git a/test/manager/utils.jl b/test/manager/utils.jl
index 670f94e9..7c9dea45 100644
--- a/test/manager/utils.jl
+++ b/test/manager/utils.jl
@@ -59,7 +59,7 @@ end
     out_file = joinpath(Franklin.out_path(Franklin.PATHS[:folder]), "index.html")
 
     @test isfile(out_file)
-    @test read(out_file, String) == "head\n<div class=\"jd-content\">\n<p>blah blah</p>\n\n\npage_foot\n</div>\nfoot  Stefan Zweig"
+    @test read(out_file, String) == "head\n<div class=\"franklin-content\">\n<p>blah blah</p>\n\n\npage_foot\n</div>\nfoot  Stefan Zweig"
 end
 
 
@@ -88,13 +88,13 @@ rm(temp_index2)
 
     clear = true
 
-    watched_files = J.jd_setup(; clear=clear)
+    watched_files = J.fd_setup(; clear=clear)
 
-    J.jd_fullpass(watched_files; clear=clear)
+    J.fd_fullpass(watched_files; clear=clear)
 
     @test issubset(["css", "libs", "index.html"], readdir(Franklin.PATHS[:folder]))
     @test issubset(["temp.html", "temp.rnd"], readdir(Franklin.PATHS[:pub]))
-    @test all(split(read(joinpath(Franklin.PATHS[:folder], "index.html"), String)) .== split("<!doctype html>\n<html lang=\"en-UK\">\n\t<head>\n\t\t<meta charset=\"UTF-8\">\n\t\t<link rel=\"stylesheet\" href=\"/css/main.css\">\n\t</head>\n<body>\n<div class=\"jd-content\">\n<p>blah blah</p>\n\n<div class=\"page-foot\">\n\t\t<div class=\"copyright\">\n\t\t\t\t&copy; All rights reserved.\n\t\t</div>\n</div>\n</div>\n    </body>\n</html>"))
+    @test all(split(read(joinpath(Franklin.PATHS[:folder], "index.html"), String)) .== split("<!doctype html>\n<html lang=\"en-UK\">\n\t<head>\n\t\t<meta charset=\"UTF-8\">\n\t\t<link rel=\"stylesheet\" href=\"/css/main.css\">\n\t</head>\n<body>\n<div class=\"franklin-content\">\n<p>blah blah</p>\n\n<div class=\"page-foot\">\n\t\t<div class=\"copyright\">\n\t\t\t\t&copy; All rights reserved.\n\t\t</div>\n</div>\n</div>\n    </body>\n</html>"))
 end
 
 
diff --git a/test/misc.jl b/test/misc.jl
index 9dfc98ec..9918da6d 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -86,7 +86,7 @@ end
 @testset "paths" begin
     @test J.unixify(pwd()) == replace(pwd(), J.PATH_SEP => "/") * "/"
     #
-    J.JD_ENV[:CUR_PATH] = "cpA/cpB/"
+    J.FD_ENV[:CUR_PATH] = "cpA/cpB/"
     # non-canonical mode
     @test J.resolve_assets_rpath("./hello/goodbye") == "/assets/cpA/cpB/hello/goodbye"
     @test J.resolve_assets_rpath("/blah/blih.txt") == "/blah/blih.txt"
@@ -100,7 +100,7 @@ end
 
 @testset "misc-html" begin
     λ = "blah/blah.ext"
-    J.JD_ENV[:CUR_PATH] = "pages/cpB/blah.md"
+    J.FD_ENV[:CUR_PATH] = "pages/cpB/blah.md"
     @test J.html_ahref(λ, 1) == "<a href=\"$λ\">1</a>"
     @test J.html_ahref(λ, "bb") == "<a href=\"$λ\">bb</a>"
     @test J.html_ahref_key("cc", "dd") == "<a href=\"/pub/cpB/blah.html#cc\">dd</a>"
diff --git a/test/parser/common_mark/cm.jl b/test/parser/common_mark/cm.jl
index d68a9a29..2ade710a 100644
--- a/test/parser/common_mark/cm.jl
+++ b/test/parser/common_mark/cm.jl
@@ -1,24 +1,24 @@
 # NOTE:
 # - this is an experimental script comparing Common Mark specs
-# with what JuDoc supports. A lot of things break but not all
-# of it is a sign of JuDoc doing the wrong thing. For instance:
+# with what Franklin supports. A lot of things break but not all
+# of it is a sign of Franklin doing the wrong thing. For instance:
 #
-# --> support for headers in JuDoc is a bit more involved adding links
+# --> support for headers in Franklin is a bit more involved adding links
 # to headers by default which Common Mark does not do so of course
 # all examples with headers currently fail.
 #
-# --> common mark accepts stray backticks, JuDoc doesn't
+# --> common mark accepts stray backticks, Franklin doesn't
 #
-# --> double backslash mean something specific in JuDoc
+# --> double backslash mean something specific in Franklin
 #
-# --> JuDoc doesn't cleanly handle <p> </p>
+# --> Franklin doesn't cleanly handle <p> </p>
 #
 # Eventually  the `similar_enough` function will be adjusted to ignore
 # those cases.
 # --------------------------------------------------------------------
 
-dir_jd = dirname(dirname(pathof(JuDoc)))
-dir_specs = joinpath(dir_jd, "test", "parser", "common_mark")
+dir_fd = dirname(dirname(pathof(Franklin)))
+dir_specs = joinpath(dir_fd, "test", "parser", "common_mark")
 tests = read(joinpath(dir_specs, "spec029.json"),  String)
 
 md = eachmatch(r"\"markdown\":\s\"(.*?)\",", tests)
@@ -73,7 +73,7 @@ function check(r)
 
         htmli = html[i]
         flag = try
-            similar_enough(htmli, mdi |> jd2html_td)
+            similar_enough(htmli, mdi |> fd2html_td)
         catch
             false
         end
@@ -88,15 +88,15 @@ function check(r)
     fails
 end
 
-jdc(i) = cleanup(preprocess(md[i]) |> jd2html_td)
+fdc(i) = cleanup(preprocess(md[i]) |> fd2html_td)
 htc(i) = cleanup(html[i])
 
 # TABS
 # NOTE: issue with `\t`
-# - also thing with first line tab (currently not accepted in JuDoc)
+# - also thing with first line tab (currently not accepted in Franklin)
 check(1:11)
 
-# PRECEDENCE (fails because judoc does not support stray `)
+# PRECEDENCE (fails because Franklin does not support stray `)
 check(12)
 
 check(13:31)
@@ -108,7 +108,7 @@ check(70)
 println("\n==Indented code blocks==\n")
 f = check(77:88)
 
-# HTML code blocks (not expected to work in  JuDoc)
+# HTML code blocks (not expected to work in  Franklin)
 # fail: all
 # println("HTML code blocks")
 # check(117:160)
diff --git a/test/parser/footnotes+links.jl b/test/parser/footnotes+links.jl
index 30eb632b..3b1513b7 100644
--- a/test/parser/footnotes+links.jl
+++ b/test/parser/footnotes+links.jl
@@ -1,5 +1,5 @@
 @testset "footnotes" begin
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
     st = """
         A[^1] B[^blah] C
         """
@@ -45,7 +45,7 @@ end
        ```
        blah
        """
-    @test isapproxstr(s |> jd2html_td, """
+    @test isapproxstr(s |> fd2html_td, """
         <pre><code class="language-markdown">this has[^1]
         [^1]: def
         </code></pre> blah""")
diff --git a/test/parser/markdown+latex.jl b/test/parser/markdown+latex.jl
index 6b8637d5..e78f9833 100644
--- a/test/parser/markdown+latex.jl
+++ b/test/parser/markdown+latex.jl
@@ -261,7 +261,7 @@ end
     @test blocks[5].name == :H5
     @test blocks[6].name == :H6
 
-    J.JD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH] = "index.md"
 
     h = raw"""
         # t1
@@ -318,29 +318,29 @@ end
 end
 
 @testset "Header+lx" begin
-    h = "# blah" |> jd2html_td
+    h = "# blah" |> fd2html_td
     @test h == raw"""<h1 id="blah"><a href="/index.html#blah">blah</a></h1>"""
     h = raw"""
         \newcommand{\foo}{foo}
         \newcommand{\header}{# hello}
         \foo
         \header
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test h == raw"""foo <h1 id="hello"><a href="/index.html#hello">hello</a></h1>"""
     h = raw"""
         \newcommand{\foo}{foo}
         \foo hello
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test h == raw"""foo hello"""
     h = raw"""
         \newcommand{\foo}{blah}
         # \foo hello
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test h == raw"""<h1 id="blah_hello"><a href="/index.html#blah_hello">blah hello</a></h1>"""
     h = raw"""
         \newcommand{\foo}{foo}
         \newcommand{\header}[2]{!#1 \foo #2}
         \header{##}{hello}
-        """ |> jd2html_td
+        """ |> fd2html_td
     @test h == raw"""<h2 id="foo_hello"><a href="/index.html#foo_hello">foo  hello</a></h2>"""
 end
diff --git a/test/parser/markdown-extra.jl b/test/parser/markdown-extra.jl
index 7ffc1631..1586ffac 100644
--- a/test/parser/markdown-extra.jl
+++ b/test/parser/markdown-extra.jl
@@ -48,7 +48,7 @@ end
         B
         `````
         C
-        """ |> jd2html_td
+        """ |> fd2html_td
 
     @test isapproxstr(h, raw"""
             <p>A
@@ -64,7 +64,7 @@ end
         ```
         `````
         C
-        """ |> jd2html_td
+        """ |> fd2html_td
 
     @test isapproxstr(h, raw"""
             <p>A
@@ -82,7 +82,7 @@ end
         bar bar
     }
     \hello
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(h, raw"""yaya  bar bar""")
 
     h = raw"""
@@ -93,7 +93,7 @@ end
             @@
         @@
     @@
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(h, raw"""
             <div class="da">
                 <div class="db">
@@ -108,6 +108,6 @@ end
     \hello{
         good lord
     }
-    """ |> jd2html_td
+    """ |> fd2html_td
     @test isapproxstr(h, "good lord")
 end
diff --git a/test/runtests.jl b/test/runtests.jl
index 1bd29e6d..d68df92c 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -6,7 +6,7 @@ const D = joinpath(dirname(dirname(pathof(Franklin))), "test", "_dummies")
 # NOTE this first file MUST be included before running the rest of the tests
 # otherwise you may get an error like "key 0x099191234..." was not found or
 # saying that the key :in doesn't exist or something along those lines
-include("jd_paths_vars.jl"); include("test_utils.jl")
+include("frank_paths_vars.jl"); include("test_utils.jl")
 
 include("misc.jl")
 
@@ -57,13 +57,14 @@ include("global/ordering.jl")
 include("global/html_esc.jl")
 
 begin
-    # create temp dir to do complete integration testing (has to be here in order
-    # to locally play nice with node variables etc, otherwise it's a big headache)
+    # create temp dir to do complete integration testing (has to be here in
+    # order to locally play nice with node variables etc, otherwise it's a big
+    # headache)
     p = joinpath(D, "..", "__tmp");
     # after errors, this may not have been deleted properly
     isdir(p) && rm(p; recursive=true, force=true)
-    # make dir, go in it, do the tests, then get completely out (otherwise windows
-    # can't delete the folder)
+    # make dir, go in it, do the tests, then get completely out (otherwise
+    # windows can't delete the folder)
     mkdir(p); cd(p);
     include("global/postprocess.jl");
     include("global/rss.jl")
diff --git a/test/test_utils.jl b/test/test_utils.jl
index 034acb83..e76d2762 100644
--- a/test/test_utils.jl
+++ b/test/test_utils.jl
@@ -37,8 +37,8 @@ function set_globals()
     J.def_GLOBAL_LXDEFS!()
     empty!(J.LOCAL_PAGE_VARS)
     J.def_LOCAL_PAGE_VARS!()
-    J.JD_ENV[:CUR_PATH] = "index.md"
-    J.JD_ENV[:CUR_PATH_WITH_EVAL] = ""
+    J.FD_ENV[:CUR_PATH] = "index.md"
+    J.FD_ENV[:CUR_PATH_WITH_EVAL] = ""
 end
 
 function explore_md_steps(mds)