If I reduce the number of words for a kanji to a handful, this goes down to about an hour or two.
If I created one page like this every Sunday, I could potentially learn at least 50 kanji per year! (Potentially.)
Although I didn’t read nearly as much as I should have this weekend, I’m more than 10% of the way to my stretch goal at the end of January:
Equivalent volumes completed:
Whose bright idea was it for me to create another kanji page, this one with ten manga examples, starting an hour before my bedtime, knowing I’d be working on it for two hours? 
I feel I’m getting a better handle on recognizing these kanji, but that’s just recency bias. I saw a two-kanji word with 送 today and recognized it immediately. (I’m remembering the reading thanks to 葬送.) Just need to see how long-lasting this is, especially when I go through more kanji.
But for now, I originally planned to go to bed early, and I’m a tad over an hour late…
I like these, thanks for making and linking them!
Somehow, I feel both behind and ahead on book clubs. (Maybe it’s because I’m in so many that I’ve fallen behind in some, and have read kind of a little bit ahead in others…)
I am doing a good job on my goal!
Equivalent of 19 volumes completed!
The disadvantage to using this goal tracking is that when I think of non-manga (non-Japanese) things I could read, I end up thinking about how I’ll fall behind on my manga-reading goal for the year. Maybe next year I should set my manga-reading goal to something like 12 volumes and get some English-language reading in?
Latest:
These end up mostly using examples from slice-of-life (I don’t need to work as hard to remember the context of a scene) and Detective Conan. If I were better at advertising things, I could probably get people to submit screenshots and information on scenes for me to add as more examples of vocabulary, grammar, etc.
Elsewhere, I’m working on methods to track vocabulary lookups I do. I’m hoping over time I’ll start see to which words I look up often, so I can focus on learning those. I can foresee issues with this method, so I’ll be trialing it for a while.
I’m especially looking forward to being more aware of when I look up a word I had previously marked as “known”.
And with this, of course, I have to have an easy way to look up a word:
(I’ll be adding similar for kanji later.)
Congrats! I like your reading goal dashboard.
Ooh, if you crack it that’s amazing.
I was just this week trying to think of a way to do this for vocab because I’m really enjoying prioritising my kanji study at the moment based on which ones I actually need to look up. And this is so different than frequency of appearance. It’s more like - which kanji are kind of generic looking to me right now and appear in a range of words across various books and so I’m not recognising them? I generally even know the words (reading/ meaning), it’s really just the kanji blur I need to fix.
And then it occurred to me I would use srs for words again if I could prioritise them by lookups. But words would be a bit unwieldy, feels like an order of magnitude harder than tracking kanji lookups
Would have fun with that! Also, you’ll get requests 
which by the way, is there an easy way to search your kurifuri site? I was thinking of seeing if you had anything on 適当 and 相当, my current nemesis pair
Unfortunately, there is not. It’s a consequence of the site being completely static, with no code behind it.
I did have a search option at one time, but it worked by storing all the text of the whole site on every page so that it could be searched from any page. The more content the site has, the larger each individual page became, so I removed it.
Google does have a solution, where I can embed a search box that lets Google handle returning the search results. Maybe I should give that a try (especially now that Google actually sees pages from the site).
I’d also love to reach a point where someone could submit manga content for pages that don’t exist on the site, and then I would write up the informational content and maybe add an additional example or three from manga I’ve read.
Initial version of a search page (still needs updates to styling before I add a link to the header):
Next I need to tackle this problem:
Only 10% of the site is indexed by Google.
Here is Google’s reason for why the other 90% is not indexed:
The page was found by Google, but not crawled yet. Typically, Google wanted to crawl the URL but this was expected to overload the site; therefore Google rescheduled the crawl.
Yay, I got a hit on 適当! So at least some of your grammar pages got crawled. The 完成 didn’t pick up but that’s probably not surprising. That will be amazing to be able to search it fully
Maybe this page will be indexed one day.
I’m toying with adding extra information about grammar and vocabulary on example pages, but I haven’t committed yet. (Example page.)
Maybe I should pick 相 for the next page I do. I should be able to find at least one example of 相当 to use.
(The “search results” are specifically based on the manga I own.)
I typically aim for the top 10 to 15 words for a kanji from Manga Kotoba, sorted by frequency. Let’s see where 相当 lands on the list…
| Reading | Count |
|---|---|
| 相手 | 30,085 |
| 相談 | 7,053 |
| 相変わらず | 4,500 |
| 相当 | 3,736 |
| 相撲 | 1,485 |
| 相性 | 1,266 |
| 相棒 | 1,047 |
| 真相 | 608 |
| 可哀相 | 541 |
| 相場 | 382 |
Time to get started on a new page!
Edit (two hours later):
I almost went a bit heavy on コナン examples. I mostly left out 相棒 because it would have ended up being another コナン scene.
These are awesome thanks!
Are you worried we’ll accuse you of indoctrinating us into Conan through irresistible vocab glosses? 
I’m working on various ways I can use my current reading processes to auto-track looked-up words. For example, when I’m using Migaku to look up a word in a manga I’m reading via Mokuro, the word automatically gets a lookup counter increment on Manga Kotoba. When I’m reading manga on my computer, word tracking is now completely effortless. (But most of my reading is on the bus, using Kobo’s e-reader software…)
I’m also considering adding an option to auto-increment the lookup counter for any word I look up on Manga Kotoba using the search page. I haven’t implemented it yet, but I’m keeping it in mind.
So far, I find I’m not using kanji tracking at all yet, even though I believe kanji tracking is more important than word tracking (at my kanji level). There’s a very small number of kanji and a very large number of vocabulary.
That got me thinking, what if I use tracked words…
…to supplement tracked kanji?
(Yes, the layout has room for improvement!)
I’ll keep “tracked kanji” and “kanji from tracked words” separate to begin with, and see if it’s something I’d like to merge into a single page (maybe with an option to filter to one or the other later).
I just have to be careful, or I’ll find myself with more Conan examples (currently 45) than I have ご注文はうさぎですか？ examples (at 117, all from volume one, since it’s the series I started the site with).
I planned to catch up on some reading (and Final Fantasy) today, but I’ve been keeping myself preoccupied with non-Japanese, non-computer things for a bit. It’s still early in the day, though.
Very slick, I’ll be interested how that goes!
And since then, I’ve been back at the computer using AI to help me with getting together example pages for my Japanese by Example site.
Old process:
New process:
I have AI run a more sophisticated version of the search tool, then take the examples, write up what happened on the prior and current pages (best guess, as it only sees the dialogue in isolation and out of order), and rates how suitable the match is for using as an example.
Example output for 「自業自得」:
Granted, the “prior page” summary is incorrect, but that’s because the AI doesn’t have enough context. I can guess the basic content of it, although I haven’t read this volume in Japanese yet. (And it’s been several years since I read it in English, so I don’t remember it. Can’t really use it as an example until later!)
This one gets a “low quality” score due to the amount of text involved.
The new process is still in development (needs more streamlining), and it’s too soon to tell if it’ll save me any time. I have the AI pick out up to ten examples, where the old method I’m seeing every text match out there. This means I may miss some good choices to use as examples. But I can always have the AI output a file matching the old method’s output, so I have that in case I need more examples (if couldn’t use all the AI-picked ones).
In the end, I only used one example from this one (as the instance I encountered in my reading yesterday is a bit too spoiler-heavy to use as an example):
Although there’s still room for improvement, I was able to go from reading this:
…to putting together this:
…in record time.
Things that helped aside from AI streamlining:
I’ve made some updates to my Progress Tracker for Mokuro Reader.
I’m finding that having it display the number of pages I should read per day to stay on track was not helpful because:
1) The number would go down as I read, so I couldn’t get a sense of how many pages I read in a day versus what my goal was. There was no clear “I don’t need to read anything else in this volume today” point to be reached.
The solution for this is to separate the pages I read “today” from my “goal per day to stay on schedule”, so I can see something like 16/35, meaning I’ve read 16 pages with a target of 35 per day.
2) Daily goals probably help if you’re only reading one to three volumes concurrently, where you might want to read a little from each per day. But what if you’re reading seven volumes, and would like to read from only one volume each day? What if you’re reading 15 to 20 volumes (like a crazy person)?
I decided to add a toggle for “pages to read this week to stay on track”. It’s too soon to say if it will be useful, but I’m looking forward to seeing how it works out (and tweaking it as necessary along the way).
Is this code something you’d be willing to share? Or give a hint how I’d be able to get started using my Mokuro library? I’ve been thinking lately that it’d be so nice to grab grammar examples from my library.. Honestly I’d probably need to also add in novels as well if I wanted to have higher coverage, but that could be a later me problem..
The code I have in place is fairly tightly coupled with how I have files set up on my system and the programming environments I have installed, but it shouldn’t be too difficult to prompt an AI model to put something together that works for you.
Here’s some options:
Anyone using Mokuro Reader can utilize the “View Series Text” option to manually copy the text from a series:
Then paste this into a text file, and have a folder with text files you can perform a text search on.
Pros:
Cons:
(Having search built into Mokuro Reader could be a very interesting side project.)
You can always perform searches on the JSON files Mokuro generates.
Pros:
Cons:
This is where we’re getting closer to what I’m doing, but it’s no longer as simple as “perform a text search on files” because you need to use code to convert the Mokuro files into something usable.
I originally wrote some Ruby or Python code to extract text from Mokuro’s JSON files into a single per-volume file that looks like:
filename [tab] line of text
filename [tab] line of text
With the advent of AI being good at code, I had one of the models convert this to TypeScript (to integrate the process into my other site that utilizes manga text).
I also adapted (probably had AI adapt) this to use the .mokuro files rather than the JSON files, although the code still has both:
public static async createSearchableText(volumeTitle: string) {
let mokuroOcrFolder = path.join(this.pendingMokuroPath, '_ocr', volumeTitle)
let ichiranOcrFolder = path.join(this.pendingIchiranPath, '_ocr', volumeTitle)
let volumeOcrFolder = (await this.pathExists(mokuroOcrFolder))
? mokuroOcrFolder
: ichiranOcrFolder
let searchableTextFile = path.join(volumeOcrFolder, 'Searchable Text.txt')
// Exit if searchable text file already exists.
if (await this.pathExists(searchableTextFile)) {
return
}
let filesToSkip = [
'i-000a.json',
'i-000b.json',
'i-zzza.json',
'i-zzzb.json',
'i-allcover-001.json',
'i-allcover-002.json ',
'i-bookwalker.json',
'i-colophon.json',
'i-flap-001.json',
'i-hyoushi-001.json',
'i-hyoushi-002.json',
]
let output = ''
// Load from Mokuro file if available.
let mokuroFile = path.join(this.pendingIchiranPath, `${volumeTitle}.mokuro`)
if (await this.pathExists(mokuroFile)) {
const fileContents = await fs.readFile(mokuroFile, 'utf-8')
// Parse the file contents as JSON
let content = JSON.parse(fileContents)
for (let page of content['pages']) {
for (let block of page['blocks']) {
let lines = block['lines'].join('')
// This should never be empty, but skip if it is.
if (lines.trim() === '') {
continue
}
output += `${page['img_path']}\t${lines}\n`
}
}
} else {
// Otherwise, load from JSON files.
let jsonFiles = await this.getFilteredFiles(volumeOcrFolder, /\.json$/)
if (jsonFiles.length > 0) {
for (let jsonFile of jsonFiles) {
if (filesToSkip.includes(jsonFile)) {
continue
}
const fileContents = await fs.readFile(path.join(volumeOcrFolder, jsonFile), 'utf-8')
// Parse the file contents as JSON
let content = JSON.parse(fileContents)
for (let block of content['blocks']) {
let lines = block['lines'].join('')
// This should never be empty, but skip if it is.
if (lines.trim() === '') {
continue
}
output += `${path.basename(jsonFile, path.extname(jsonFile))}\t${lines}\n`
}
}
}
}
await fs.writeFile(searchableTextFile, output, { encoding: 'utf-8' })
}
Now a search can be done fast, and you know which image file it’s from.
I keep these in the _ocr folder for each volume they are from, but I symlink them into a single location so I can run a search on just one folder:
I wrote a simple Python script that can search throutgh this for a specfic text and generate an HTML file with search results:
from natsort import natsorted
import json, os, re
search = '人相' # also supports regex!
series_name = ''
def find_ocr_folders(directory, series_name):
subfolders_with_name = []
for dirpath, dirnames, filenames in os.walk(directory):
if '_ocr' in dirnames:
subfolders_with_name.append(os.path.join(dirpath, '_ocr'))
if not series_name:
return subfolders_with_name
return list(filter(lambda k: series_name in k, subfolders_with_name))
def list_subdirectories(directory):
subdirectories = []
if not os.path.exists(directory):
return subdirectories
for entry in os.listdir(directory):
entry_path = os.path.join(directory, entry)
if os.path.isdir(entry_path):
subdirectories.append(entry_path)
return subdirectories
def get_parent_folder_name(path):
parent_folder = os.path.basename(os.path.dirname(path))
return parent_folder
def get_json_files(directory):
json_files = [f for f in os.listdir(directory) if f.endswith(".json")]
return json_files
def read_searchable_text_file(volume_directory, search_text_file):
json_file_names = natsorted(get_json_files(volume_directory))
if not os.path.isfile(search_text_file):
return create_searchable_text_file(volume_directory, search_text_file)
else:
with open(search_text_file, 'r', encoding='utf-8') as file:
return file.read()
def create_searchable_text_file(volume_directory, search_text_file):
json_file_names = natsorted(get_json_files(volume_directory))
output_texts = []
if not os.path.isfile(search_text_file) or True:
for json_file_name in json_file_names:
json_file = os.path.join(volume_directory, json_file_name)
with open(json_file, 'r', encoding='utf-8') as file:
data = json.load(file)
if not 'blocks' in data:
continue
for block in data['blocks']:
if not 'lines' in block:
continue
output_texts.append(f"{os.path.splitext(json_file_name)[0]}\t{''.join(block['lines'])}")
output = '\n'.join(output_texts)
with open(search_text_file, 'w', encoding='utf-8') as file:
file.write(output)
return output
def get_image_file_path(volume_directory, image_base_name):
# Get the path to the original image.
path_list = volume_directory.split(os.path.sep)
path_list.remove('_ocr')
image_directory = os.path.sep + os.path.join(*path_list)
image_without_extension = os.path.join(image_directory, image_base_name)
common_extensions = ['.jpg', '.jpeg', '.png']
for extension in common_extensions:
possible_file = image_without_extension + extension
if os.path.isfile(possible_file):
return possible_file
return ''
def html_for_match(match, volume_directory, image_base_name):
image_file_path = get_image_file_path(volume_directory, image_base_name)
line_with_style = line_text[:match.start()] + '<strong>' + match.group() + '</strong>' + line_text[match.end():]
return f"<li tabindex='0' onfocus='showImage(this, \"{image_file_path}\")'>{image_base_name}: {line_with_style}</li>"
# Get a list of all _ocr folders.
ocr_folders = natsorted(
find_ocr_folders('/home/chris/Books/Comics/Japanese/', series_name)
+ find_ocr_folders('/home/chris/Books/Comics/Finished/', series_name))
output_lines = []
output_lines.append('<!DOCTYPE html>')
output_lines.append(f'<title>{search}</title>')
output_lines.append('<link rel="stylesheet" href="styles.css">')
output_lines.append('<script src="script.js"></script>')
output_lines.append('<div id="parent">')
output_lines.append('<div id="matches">')
for ocr_folder in ocr_folders:
series_name = get_parent_folder_name(ocr_folder)
match_found_for_series = False
volume_directories = natsorted(list_subdirectories(ocr_folder))
for volume_directory in volume_directories:
volume_name = os.path.basename(volume_directory)
match_found_for_volume = False
search_text_file = os.path.join(volume_directory, f'{volume_name} Searchable Text.txt')
text = read_searchable_text_file(volume_directory, search_text_file)
lines = text.strip().split('\n')
for line in lines:
image_base_name, line_text = line.split('\t')
match = re.search(search, line_text)
if match:
if not match_found_for_series:
output_lines.append(f'<h2>{series_name}</h2>')
match_found_for_series = True
if not match_found_for_volume:
output_lines.append(f'<h3>{volume_name}</h3>')
output_lines.append('<ul>')
match_found_for_volume = True
output_lines.append(html_for_match(match, volume_directory, image_base_name))
if match_found_for_volume:
output_lines.append('</ul>')
output_lines.append('</div>')
output_lines.append('<div id="page">')
output_lines.append('<a id="link" target="_blank"><img id="image" /></a>')
output_lines.append('</div>')
output_lines.append('</div>')
output_lines.append('<script>')
output_lines.append('buildTableOfContents()')
output_lines.append('</script>')
output_file = 'results.html'
with open(output_file, 'w', encoding='utf-8') as file:
file.write('\n'.join(output_lines))
(For some reason, the output only works in Firefox, not in Chromium-based browsers.)
I’ve recently been testing a different Python script crafted by AI. It still needs more work, but currently it tries to pull only ten examples, analyze them for how useful they would be for my Japanese by Example site, and extract the whole text from the page with the match and the page before it. AI then takes this text and tries to summarize what’s happening on each page (keeping in mind it’s seeing text out of order, sometimes with OCR errors, and no vision to see what’s happening on the pages).
For anyone interested in help getting something similar set up, I can be available on Discord sometime.
Thanks for the detailed explanation I’m currently not using Mokuro Reader; I’m actually using a very heavily modded by AI version of yukitanuki’s manga server, so method 2 is going to be my path..
I’ll try and get started using AI and I might ping you on Discord if I get too stuck. Thanks again, this is super helpful!
On actual volumes completed, I’m 20 of my way to my 2026 goal of 125 volumes! (I’ve given up on 100 being the goal and 125 being a stretch goal.)
On equivalent volumes completed, I’m at 29 volumes.
I’ve added weekly reading goals to Mokuro Reader, but I kind of focused on reading One Week Friends through the end, and now I seem to be binging Blue Box lately. That’s making my weekly progress look really, really bad…
There are still a few things I need to test out in the Progress Tracker, but I feel I’m getting pretty close to being able to create a Pull Request to see about having it added into the main Mokuro Reader. The last must-account-for piece is ensuring any data used by the Progress Tracker is preserved when using the sync functionality.
I’d recently tried adding “Vocabulary” and “Grammar” sections to some example pages, but kept hitting on things that felt like they could go into either section.
I decided to try a different approach. After about seven hours of trying out different things, I’ve settled upon a “Key Points” section that aims to highlight a few random bits of grammar or vocabulary from the example text:
I’ll probably improve this further over time, but for now, the workflow is:
Use GPT 5.2 to generate an initial list. (I find GPT 5.4 does equally as well; I’ll probably stick with it going forward. All other models I’ve tried were very much sub-par for this task.)
I review each item, making any fixes, changes, or removals I deem necessary. (This is a very important step, and is necessary for each page I run this on.)
My hope is that one of those few people a year who land on the site and it’s exactly what they’re looking for, aside from reading a manga example of grammar or vocabulary they’re curious about, they’ll also pick up something useful from the Key Points section.
I’d say this content may even improve the site’s Google search rankings, but a few weeks ago the site only had about 160 out of about 580 pages indexed. Then that suddenly dropped to only 20 pages. Most of the site was just gone from Google. At this point, I don’t have much faith in Google ever driving traffic to the site. On a good note, the site’s actually up to 200 pages indexed, so there is that.
The reason for the drop may be due to the encoding of the URL. (Just a guess. Google doesn’t give a reason.) I did make the conscious decision to have Japanese in the URL, but didn’t expect that several years later, it would still be an issue for Google (assuming that it is the issue). Hopefully my adding the “canonical” link to pages will help Google out a bit.
Some weekends I get reading in. Some I don’t. When I don’t, I wonder how much it’s hurting my progression toward a goal of 100 125 volumes read in 2026.
I should be 20% into my goal by now, as we’re on the 74th out of 365 days for the year.
Current progress: 25% on the dot.
The good news is that I’m well ahead of my goal.
The bad news is this doesn’t give me a push to read on weekends.
Maybe I can use the weekends to actually get through Final Fantasy 2. I don’t even want to know if the Final Fantasy club is already in Final Fantasy 3 yet.
Looking over my completed reads, I’m seeing clear patterns for putting focus on a series for a few volumes at a time:
I wonder if I should add an option to swap between volume view and series view. A series view would show only the most recently completed volume per series, and underneath would list the number of volumes in that series completed in the reading period. That would make it easier to see which series I’ve put the most progress into.
Although I’m still behind on a number of series, I’m really liking that I’ve added weekly page goals as an option (versus just daily):
My reading week starts on Saturday, and I haven’t read since Friday, so the progress stats are not looking so great at the moment!
Please ignore that I’m rather ahead on some book clubs, and super behind on other book clubs.
For the Spring Equinox readathon, I’ll try setting a one-day goal and see how well it works out. If all goes smoothly, then I’ll begin the process to submit the Progress Tracker to the main Mokuro Reader codebase. I just need to gather together all the new information the tracker stores, and ensure that it’s retained if someone syncs their data between browsers.
I’ve decided that Google just does not like this site of mine. Between finding new pages and leaving them unindexed, and randomly unindexing older pages, it’s useless to use for the site’s embedded search:
Issues:
I learned today about Pagefind, and it’s a much better solution for my site:
Only minor issue from this search result is that the third result didn’t excerpt the portion I wanted it to, but it’s not a big deal; more important is that this is returning the actual pages I’d want someone to find when doing a search.
With this, the site finally has a search button to bring up the search page:
Today I am writing a bit about my website, Japanese by Example. Nothing else in this post, so feel free to disregard!
The site started out as a blog where I wrote about learning grammar and vocabulary as I read struggled deciphered my way through the first volume of ご注文はうさぎですか？.
Later on, I decided to convert that into an actual site, powered by WordPress. Here I’d write down brief notes on grammar, then include examples of the grammar used in manga, with a manga panel screenshot and the dialogue typed out, and a blurb about the grammar as used in that dialogue.
As it turns out, WordPress wasn’t suitable for this, and I’m eternally grateful to @NicoleIsEnough for suggesting Jekyll. I did recently explore what a transition from Jekyll to Astro would look like, but in the end, the pros of Astro weren’t strong enough, and the cons of Astro were too strong to be worth the switch. So still on Jekyll.
I’ve had various issues along the way with how the site was presented to Google which caused Google to basically avoid indexing the site for about five years. And even after resolving all of that, Google still tried to ignore indexing pages.
It does make sense, if the grammar pages are minimal (letting manga examples be the star), and the manga example pages are fairly bare, there’s not much there that Google would want to showcase (present in search results).
I’ve been a fan of the Mangajin/Japanese the Manga Way presentation for some time now.
Although I’ve attempted to mimic the format (with per-word translations and a bullet list of notable bits), I’d decided to keep things as I had them.
With OpenAI’s Codex, I find I can automate some interesting things, such as generating a kanji page with words that include descriptions far better than I could write up. And in much less time. I currently have about 50 such pages that are only waiting for me to look for about one to five examples per page to create example pages for, then they’ll be ready to upload.
(I normally have it generate about 15 kanji pages at a time, but for screenshots here, I’ll do just one.)
I then review the summary and etymology for issues (with pure blind faith in Wiktionary not to lie to me about the etymology).
Next, search for example pages that already use this kanji:
My current focus is on two-kanji compounds. The results here are: 放送, 解放, and 放課後.
The first one has an entry on the new kanji page already, so I add it as an example:
Then I read over the summary and kanji lines to ensure everything looks good to me, and make any changes I feel necessary. The “kanji” line here can probably use some work, but offhand, I’m not certain how I’d like to improve upon it.
I also see the “secondary” class has been added where it shouldn’t be, so I’ll need to clean that up:
I think I would like to add a page for 放課後, so:
Please add an entry for 放課後 to this page.
I mis-saw “looser atmosphere” as “loser attitude” and thought for a half-second that I was going to need to do a deep dive on 放課後…
The kanji page has 11 word entries, but only three with examples. (Entries without examples are not displayed.)
Of those three examples, two are from pages specificially showcasing words with this page’s kanji, and one is unrelated.
My goal is to have at least one word extra with an example page showcasing the word, so this one fits that requirement. If there were no example pages meeting that requirement, I wouldn’t upload this one until I created at least one such example page.
But before I can upload it, I need to go through each example page and ensure it has a “key points” section. This is just a few points about the grammar and vocabulary and such from the dialogue on the example page, with the first entry related to the point the example page is showcasing.
Only one of these pages is missing this, so I’ll add it now:
This often breaks the page (I need to update the skill used to add the section to avoid this). So there’s a tiny bit of cleanup there, along with adjustments to formatting, wording, and punctuation.
I also look for things like point two shown above that, while possible to work into a good point, just read as kind of silly to me as written and for now I just cut those out.
End result:
Back when I converted my blog entries into an actual website, I went with the name “Japanese by Example”. I considered naming it “Japanese with Manga” (or maybe a bit later considered renaming it as such), but then I learned there was a (very excellent) website called “Japanese with Anime” and I didn’t want to look like I was trying to ride the coattails of such an existing site.
But now that my site’s been around in one form or another for over eight years (
), I’ve finally renamed the site to “Japanese with Manga” and bought a domain name for it.
I’ve read that Google makes no ranking distinction between whether a website is at a subdomain (like “Japanese by Example” was) or a domain (like “Japanese with Manga” is). As such, I’m expecting is to be a while before Google gets anywhere near having 200 pages of the site’s new location indexed. And that much will primarily be from Google seeing the old site pages perma-redirecting to the new site.
That said, let’s see how close it is to getting 200 pages indexed:
Oh.
It’s indexed 522 pages.
Um…
I kind of don’t know what to say about this.
The site’s starting to show up in search results for the kinds of things it’s intended to help with, although I probably need to improve the descriptions that appear in search results.
Can I take a moment to dislike that the clickbait-sounding article title “Best manga for Japanese beginners” is my top performer in showing up in search results? Once I get around to adding descriptions to article pages so the search result makes it look like a page worth clicking through, it could end up being a primary source of traffic…
I always find the country breakdown to be a fun view:
The trick is that the Japanese and South Koreans can’t tell if the page description in the search result is good or bad, so it doesn’t deter them from clicking.
I was going to say the device listing looks like a win for me, because it shows I can ignore improving the mobile layout:
But then I realized I have a 1% click-through rate on desktop and 3% on mobile…
I’m going to go re-read my page on 放. It’s not a kanji I struggle with, but I can always improve my foundation on it.
